Taller RpgMaker xp

Ejemplo_de_puzles

2012-05-05T09:12:00.004-07:00

Titulo : Ejemplo_de_puzles
Autor : ?
Tipo : Hibrido
Version : ?
Descripcion : varios ejemplos de puzles
Descarga

Ejemplo Reflejo_por_Kandorf

2012-05-05T09:11:00.002-07:00

Titulo : Ejemplo Reflejo_por_Kandorf
Autor : Kandorf
Tipo : Engine
Version : ?
Descripcion : un engine de reflejo
Descarga

Ejemplo puzle_por_Kandorf

2012-05-05T09:08:00.004-07:00

Titulo : Ejemplo puzle_por_Kandorf
Autor : Kandorf
Tipo : Engine
Version : ?
Descripcion : un ejemplo de puzles
Descarga

Ejemplo menu titulos de anillo

2012-05-05T09:07:00.003-07:00

Titulo : Ejemplo menu titulos de anillo
Autor : Dark_Wolf_Warrior
Tipo : Script
Version : ?
Descripcion : menu de titulos con un menu anillo
Descarga

Ejebanco

2012-05-05T09:05:00.002-07:00

Titulo : Ejebanco
Autor : ?
Tipo : Engine
Version : ?
Descripcion : un ejemplo de banco
Descarga

Efecto de luces

2012-05-05T09:04:00.004-07:00

Titulo : Efecto de luces
Autor : SephirothSpawn
Tipo : Script
Version : ?
Descripcion : agrega un script de linterna
Descarga

Easy intro script

2012-05-05T08:52:00.002-07:00

Titulo : Easy intro script
Autor : Slipknot
Tipo : Script
Version : ?
Descripcion : introduccion tipo star wars
Descarga

Easy Character_Creator

2012-05-05T08:51:00.000-07:00

Titulo : Easy Character_Creator
Autor : Kotfire
Tipo : Script
Version : 2.0
Descripcion : permite crear desde 0 a un personaje, personalizandolo totalmente
Descarga

Dynamic Time

2012-05-05T08:49:00.004-07:00

Titulo : Dynamic Time
Autor : ccoa
Tipo : Script
Version : ?
Descripcion : implementa un sistema de tiempo meteorologico dinamico
Descarga

Dynamic Stores Demo

2012-05-05T08:47:00.003-07:00

Titulo : Dynamic Stores Demo
Autor : Astro_mech
Tipo : Script
Version : ?
Descripcion : hace que los onbjetos varien en una misma tienda
Descarga

Engine de iluminacion dinamica

2012-04-14T20:31:00.000-07:00

Este es un engine experimental, favor de no usarlo con demasiados efectos y otros eventos corriendo en paralelo, porque causa lag.

Bueno, primero comenzamos con la animacion, ustedes se pueden fabricar una como quieran, yo la cree en el firework y me quedo bastante bien(no se ve, pero esta ahi la imagen):

Despues, con esta imagen crean la animacion para los 4 puntos cardinales:

Despues en el evento comun PP - Datos heroe comprueban las direcciones en que mira el personaje, y le activan y desactivan los interruptores de las direcciones, uno para cada direccion:

Despues, por cada interruptor crean un evento comun que llame a la animacion, que son 4:

Ya con esto deberia funcionar el engine, ahora tienen que agregar la tecla para activar y desactivar el sistema, para esto ocuparemos la tecla W:

Primero creamos el sistema de encendido y apagado:

Luego agregamos la tecla para prender y apagar la linterna:

Y por ultimo, agregamos que el sistema funcione solo cuando el interruptor este en On:

Tambien podemos agregar algunas otras cosas, como por ejemplo, una animacion de graficos al sacar y guardar la linterna, ponerle duracion a esta (pilas o baterias), etc, es cosa de imaginacion, yo solo hice la manera simple de ponerla.

El mapa, para que quede bien configurado, tiene que tener una terreno de color calido (si ponen negro no se vera nada, el color cafe o verde se ve bien este engine, en un terreno de color gris oscuro no se ve nada)
Usen esta mezcla de colores para que quede bien oscuro:

Para crear luces, por ejemplo, solo deben crearle su animacion de luz, y hacer que esta se repita, para esto usen las etiquetas.

Con esto terminamos el tutorial.

Tutorial de optimizaciones 3

2012-04-14T18:28:00.000-07:00

En este tutorial opimizaremos el evento mina

Primera hoja:
Igual que antes, solo le rebajamos el tiempo de espera a 1 frame.

Segunda hoja:
Aqui agregaremos esta linea de codigo, mediante un llamar sript:

$game_variables[10]=@event_id

Aqui le estamos indicando a la variable 10 que guarde el id de ese evento, para poder usarlo mas tarde, si lo hiciste bien, el contenido de la segunda hoja luciria como esto:

Tercera hoja:
En esta hoja usaremos la siguiente linea de codigo para verificar si el personaje est dentro del area de la mina, para si poder hacerle daño:

$view_range.enemies_view(ev_id, v_range, sw_id, s_sw_id, block)

Vimos algo similar en la clase pasada, asi que no hay necesidad de explicarlo nuevamente, si queda bien configurado se veria algo asi:

Despues solo tienen que verificamos que el interruptor local A este encendido, le ponemos el calculo del daño, una animacion y la desactivacion del interruptor despues de un tiempo, si lo hicieron bien, quedaria algo asi:

Nos ahorramos las variables mina x2 y mina y2 para el calculo del daño al personaje.

Con esto terminamos el tutorial.

Tutorial de optimizaciones 2

2012-04-14T16:35:00.000-07:00

En este capitulo reharemos desde 0 a nuestro evento enemigo, manteniendo sus caracteristicas y dandole animacionesal momento de atacar.

Primera hoja:
La configuraremos con el grafico que deseamos y como proceso paralelo, y usando esta linea de codigo que mostramos en la clase anterior:

Basicamente estamos solicitando la funcion de rango de vision co forma de cono.

Segunda hoja:
Aqui usaremos el mismo grafico y lo configuraremos en proceso paralelo, con condicion de aparicion el interruptor local A, ponemos lo siguiente:

Aca configuramos lo que queremos que realice el enemigo al detectarnos dentro de su rango de vision, en este caso haremos 2 configuraciones distintas, ataque a larga distancia y ataque cuerpo a cuerpo, comenzaremos con el ataque a larga distancia:

Tercera hoja:
Primero lo configuramos como proceso paralelo con condicion de aparicion el interruptor local B, luego reseteamos el tipo de rango de vision usado, la cambiamos a lineal, no agregamos el interruptor local a activar, ya que el script por defecto activa el "A".

Ahora consultamos si el interuptor esta activo:

Despues configuramos el daño y las animaciones al personaje en caso de que este este dentro del area de ataque del enemigo, usamos una variable para asignar un valor aleatorio, luego este valor lo pasamos como daño al personaje, ponemos un sonido x al personaje y una animacion que lo acompañe:

Por ultimo ejecutamos la animacion del grafico del enemigo, una espera de tiempo pertinente para que no nos acribillen y desactivamos el interruptor "A" para no crear un bucle.

Cuarta hoja
Primero lo configuramos como proceso paralelo con condicion de aparicion el interruptor local C, luego reseteamos el tipo de rango de vision usado, la cambiamos a circular:

Ahora consultamos si el interuptor esta activo:

Despues configuramos el daño nuevamente:

Por ultimo la animacion y la desactivacion del interruptor como en la hoja 3:

Quinta hoja:
Aqui mantendremos la configuracion por el momento:

Sexta hoja:
En esta hoja haremos uso de este script, que permite calcular rangos de vision, porque uso otro en vez del que uso en los enemigos, por tres cosas simples:

permite la funcion evento ve evento
me permite configurar si es un interruptor local o uno normal
tambien puedo bloquear la vision con las paredes

La configuracion de esta hoja es la misma que la del otro evento en la parte del calculo de daño de la mina, lo unico que cambia es el contenido, comenzaremos usando la llamada de script con esta linea:

$view_range.event2event_view(ev_id, ev2_id, v_range, sw_id, s_sw_id, block)

ev_id = usaremos el comodin @event_id ya que asigna automaticamente el id del evento
ev2_id = usaremos $game_variables[10], esta variable tiene guardado el id del evento mina

v_range = el rango a ver, pondremos un valor no superior a 7 para minimizar el lag

sw_id = el interruptor a activar, en este caso no lo ocuparemos, asi que le pondremos nil

s_sw_id = el interruptor local a usar, en este caso "A", con las comillas

block = el bloqueo de vision de las paredes, en este caso true

Configurado deberia quedar de esta forma:

Despues verificamos que el interruptor A este activo, luego le sumamos a la vida del enemigo el daño de la bomba, despues ponemos una animacion de daño sobre el enemigo, y por ultimo un tiempo de espera mas la desactivacion del interruptor usado:

Septima hoja:
Es exactamente lo mismo que la hoja donde muere el enemigo en el otro evento:

Con esto finalizamos la opimizacion del evento enemigo.

Tutorial de optimizaciones 1

2012-04-14T11:59:00.000-07:00

Optimizando el engine de ascensor:

Comenzaremos haciendo unas pequeñas modificaciones al engine de ascensor que nos permitira:

Ocupar una variable menos.
Marcar el numero del piso en el que estamos, como tambien ir cambiando el numero en la medida que subamos o bajamos.

Comenzaremos con lo primero, ponerle nombre a los 3 eventos qe tenemos, para poder dar bien las indicaciones, el evento que hace de puerta le pondremos puerta, el que esta al lado le pondremos core, y el que esta sobre este le pondremos inmovil.

Con esto claro comenzamos con el trabajo:

Primero vamos al evento core, alli en la tercera hoja buscamos en la seccion de presionar tecla c lo siguiente:

Lo que vamos a hacer aqui es eliminar el calculo que hacemos con la variable piso temp, y traspasarla directamente a los calculos del piso actual, basicamente seria algo asi:

si piso actual es mayor que al piso que queremos ir, le restamos 1
si piso actual es menor que al piso que queremos ir, le sumamos 1

Con esto sabremos en que piso va el ascensor al momento de subir o bajar, nos ahorramos el uso de una variable, y acortamos la cantidad de programacion al engine, que es lo que buscamos, al hacer esto deberia quedar algo asi:

Ahora testeamos que funcione correctamente, despues pasamos al segundo punto:

Poner el piso en que estamos: crearemos un nuevo evento al que le pondremos el nombre de numero, a este evento le pondremos la condicion de que si variable piso actual es igual a x numero, que cambie el grafico automaticamente, lo dejaremos corriendo en proceso paralelo, quedando algo asi:

Ahora testeamos nuevamente su funcionamiento, terminando la modificacion a nuestro engine de ascensor.

Optimizando el engine de sistema de ataque cuerpo a cuerpo, distancia y armas de fuego:

Para esto recurriremos a los script, especificamente al Tactical Espionage Engine, que nos permitira reemplazar el uso de las variables para calcular el area, este script nos permite tener rangos de vision como:

TIPO 1: Diamante
TIPO 2: Piramide
TIPO 3: Lineal
TIPO 4: Circulo
TIPO 5: Cono

Tambien permite el bloqueo de la vision de los enemigos por las paredes con solo cambiar el numero del id del terreno(solo funciona para el tipo 5).

Su funcionamiento es mediante notas, que deberian llevar esto:

Fov(TIPO,DISTANCIA,INTERRUPTOR LOCAL)

Su configuracion es simple, y hace exactamente lo mismo que haciamos con los engines, ahora comenzaremos con los reemplazos que debemos hacer:

Vamos a nuestro enemigo, y en la hoja 1 sacamos esto:

Y lo reemplazamos por esto:

Simple, no?

Ahora podriamos probarlo con nuestro sistema, pero tenemos un problema, este script trae algunos agregados interesantes, que ocupan nuestras mismas teclas, para poder ocuparlo haremos unas cuantas modificaciones a nuestro sistema, quedando una cosa asi:

Engine:
Tecla A = poner mina o detonarla
Tecla S = guardia arma a distancia o de fuego
Tecla S+D = ataque de arma cuerpo a cuerpo, a distancia y de fuego
Tecla S+A = recarga arma de fuego
Tecla D = desocupada
Tecla Q = llamar al menu(por el momento)
Tecla W = desocupada

Script:
Tecla Z = modo siguilo
Tecla X = Correr
Tecla C = funciones por defecto en el maker

Como ven tenemos un sistema bastante complejo, al cual aun le podemos agregar algunas cosas, pero eso lo veremos mas adelante, ahora solo realizaremos la modificacion de las teclas correspondientes:

Asi quedaria el evento del sistema, testeamos y con esto damos por terminada la primera clase de optimizaciones.

Advanced Windows

2012-04-12T08:18:00.000-07:00

Este manual pertenece a esta pagina.

Traducido por Tenshi98

Advanced Windows:

I. Introducción
II. Utilizando los métodos de dibujo
III. Mostrar fotos
IV. Opacidad de las ventanas
V. Conclusión

I. Introducción

Bienvenidos a la lección de los Constructores de script. Hasta el momento, sabemos cómo hacer que Windows Basic y Windows seleccionables. En este tutorial vamos a aprender cómo mostrar información útil, no sólo texto. Además, en este tutorial, voy a estar enseñando a ustedes de una manera diferente. Habrá tres clases de mini-lecciones dentro de esta lección, que son el 'Uso de los métodos de dibujo', 'mostrar imágenes', y 'opacidad de la ventana'. ¿Por qué estoy haciendo de esta manera? Por dos razones. Uno, es una forma más efectiva para enseñar, no solo hare un script y le dire que significa, sino que voy a estar mostrando a ustedes cómo manipular cada parte para que tengan una mejor comprensión de todo. Y dos, me sentiré mejor cuando le de una tarea voy a saber que no sólo van a copiar el script que hice al final y sólo cambiar alguno de los valores, ya que no habrá ninguno, sino que en realidad estaran pensando en cómo se puede juntar las piezas de los tres mini-lecciones en un script. Sin más preámbulos, vamos a comenzar el tutorial :)

II. Utilizando los métodos de dibujo

Los métodos de dibujo son herramientas muy útiles al hacer sus ventanas. Recuerden lo que enseñe en el tutorial básico de Windows, que los métodos son bloques de código se puede reutilizar a través de su script. Ejemplos de estos métodos de dibujo incluyen:

Code:

draw_actor_hp(actor, 0, 0)

Code:

draw_actor_state(actor, 0, 0)

Los códigos anteriores se utilizan para dibujar los datos personales de un actor y su estado. Los parámetros, los valores dentro del paréntesis, de los dos métodos son de izquierda a derecha: el actor que se pasa a través del método, la coordenada x del texto, y la coordenada y. Usted puede encontrar todos los métodos de dibujo de las líneas 102 a 321 de Window_Base.

Ahora, sin más preámbulos, vamos a utilizar estos métodos de dibujo!

En primer lugar, sacar ese esquema de base de la ventana Bloc de notas y lo abrimos. Copiar en el editor de script de un proyecto RMXP nueva y ponerla justo encima de Main. Nombraremos a este script como "Advanced Window" en el espacio provisto a continuación el script principal.

Ahora, en la línea dos del script, escriba el nombre de nuestra clase después del símbolo de comentario, que va a ser 'Window_Advanced'. En la línea cuatro de la secuencia de comandos, escriba una descripción tan simple como "Esta clase utiliza los métodos de dibujo". Ahora, en la línea siete del guión, que comienza con "class", le indicaremos que estamos heredando de Window_Base:

Code:

class Window_Advanced < Window_Base

Ahora, antes de continuar con nuestro script, tenemos que tener una idea clara de lo que se va a hacer. Puesto que tenemos la intención de mostrar los valores de actores que utilizan nuestros métodos de dibujo, vamos a hacer una base de un HUD que muestra el Exp. HP, SP, y el nombre del primer carácter de su grupo (Vamos a llegar a un HUD que muestre los cuatro miembros del partido en tutoriales posteriores). Por lo tanto, nuestra ventana no debe ser tan grande. Por lo que nuestra coordenada X y coordenada y (los dos primeros valores en el paréntesis junto a la palabra clave super) vamos a dejarlos a 0 para que podamos tener nuestra ventana en la esquina superior izquierda de la pantalla. Nuestra anchura (tercer valor) debe ser de 200 y nuestra altura (último valor), debe ser de 150.

Ahora, vamos a pasar a nuestro método de actualización. Para empezar, vamos a escribir el nombre de nuestro actor en la primera línea de nuestra ventana. El código para dibujar el nombre de un actor es el siguiente:

Code:

draw_actor_name(actor, x, y)

Pone esta línea de código después de esta línea:

Code:

self.contents.clear

Pero espera, ¿qué es el "actor" a la izquierda como el primer valor en el paréntesis del método draw_actor_name? No se ha asignado un valor a la misma, así que por que se está haciendo de esa manera? Bueno, ¿por qué no asignar un valor a "actor" para que sepamos a que el actor que está dibujando el nombre? Antes de la línea draw_actor_name, pongan esta línea de código:

Code:

actor = $game_party.actors[000]

Esta línea de código nos permite ir a través de los actores en su $ game_party, hemos optado por el primer actor en la lista de los actores en la base de datos. Si estas en un nuevo proyecto de RMXP, lo que significa que sólo eligió Aluxes, lo que significa que nuestro método draw_actor_name sacará el nombre de Aluxes, que es Aluxes.
A continuación, cambiar el valor de x en 0 y el valor de y en 0 en los parámetros de dibujo en draw_actor_name de modo que nuestro texto está en la esquina superior izquierda de la pantalla.

Ahora, todo lo que tenemos que hacer es darle un espacio el resto a nuestro texto en alrededor de 30 píxeles. Así que, básicamente, que debemos copiar el resto de los métodos de dibujo que necesitamos en nuestro método draw_actor_name teniendo básicamente tres líneas más de código en nuestro método draw_actor_name. Estas tres líneas se verían así:

Code:

draw_actor_hp(actor, 0, 30)

draw_actor_sp(actor, 0, 60)

draw_actor_exp(actor, 0, 90)

Como usted puede notar, el único cambio que hemos hecho dentro de los parámetros es aumentar el valor y por 30 píxeles por cada línea de texto.

Si es así, pasaremos a mostrar la ventana con eventos como se explica en los dos últimos tutoriales (por lo que no debería tener que explicar de nuevo). El resultado final debería tener este aspecto:

Si es así, enhorabuena, estás a un paso más cerca de hacer ventanas complejas :)

III. Mostrar fotos

Este mini-tutorial es bastante difícil de entender, pero es de esperar, que serán capaces de seguir mis explicaciones.
En primer lugar, abra su editor de script en un proyecto RMXP nuevo e ir al modulo Window_Gold para ver su script. Para poner una imagen, es necesario definir un método que he aprendido como método draw_picture (sí, esto es técnicamente una draw_method, así que usted puede ponerlo en el script Window_Base si lo desea, para que no tengan que definirlo todo el tiempo). Después de la línea 15 del script Window_Gold, hagan un espacio para poner esta línea de código:

Code:

def draw_picture(x, y)

Como puedes ver, hemos acabado de definir un método llamado draw_picture y ajustar sus parámetros a x e y que llegará a utilizar más adelante en nuestro código.
A continuación, agregue esta línea:

Code:

bitmap = RPG::Cache.picture("")

Esta línea asigna un valor a la variable de mapa de bits. El valor asignado es una imagen uqe estara guardada en nuestra carpeta de recursos. La forma en que el sistema sabe qué imagen estamos hablando es colocando el nombre de la imagen dentro de las comillas de la línea. Asi que guardaremos una imagen al azar dentro de la carpeta Pictures de nuestra carpeta de recursos, a la cual llamaremos "picture".

Al llamar la imagen, lo haremos por su nombre, asi que tomaremos el script anterior, y pondremos entra las comillas el nombre de la imagen agregada anteriormente, quedando algo asi:

Code:

bitmap = RPG::Cache.picture("picture")

Despues de esta linea, agregar esta otra:

Code:

src_rect = Rect.new(0, 0, bitmap.width, bitmap.height)

¿Qué hace esta linea? Bueno, acabamos de asignar un nuevo valor a otra variable. Este valor asignado es un rectángulo. Cuando escribes Rect.new, eso significa que estás dibujando un rectángulo que es donde vamos a mostrar nuestra imagen. Cuando se hace un nuevo objeto de la clase Rectangle, tienes que definir sus coordenadas X e Y, su anchura y altura. Bueno, para el ancho y alto, todo lo que tienes que hacer es hacer lo mismo de la anchura y la altura de nuestra imagen. Por lo tanto, sería bitmap.width y bitamp.height puesto que asigna nuestra imagen a la variable de mapa de bits. Acaba de salir de sus valores X e Y igual a cero, ya que son los valores simplemente ficticias, nuestros valores x-y reales se definirán más adelante.

Esta es la ultima linea de nuestro metodo:

Code:

self.contents.blt(x, y, bitmap, src_rect)

Agreguen esta línea después de la última línea que acaba de agregar. Lo que esta línea de código que hace es poner todo junto. Esto hace que la imagen establecida en su valores xey (que se definirá más adelante), la imagen , y el rectángulo sean dibujadas.

Después de esa línea, poner la palabra clave 'end' para demostrar que cerramos nuestro método. Lo último que tenemos que hacer definir nuestros valores X e Y que se suceden en nuestro método de actualización como cualquier otra draw_method.

Añadir un espacio después de la línea self.contents.clear y poner esta línea de código en:

Code:

draw_picture(x, y)

Cambia los valores X e Y por los que quieras (yo lo hice algo sencillo y puse a ambos en cero). Por lo tanto, nuestro editor de script debe verse similar a esto:

Ve al menú para ver si hay una imagen en la ventana del oro. Si la hay, entonces felicidades, ya sabes cómo mostrar imágenes.

IV. Opacidad de las ventanas

Este mini tutorial debe ser muy fácil de entender. En primer lugar, vaya el editor de scripts en un proyecto de RMXP e ir al script de Window_Item. En este mini-tutorial vamos a hablar básicamente acerca de cómo cambiar la opacidad de las ventanas. Ve a la línea 15 del script y crea una nueva línea, despues copia la linea que hay a continuacion dentro del script de esta ventana:

Code:

self.back_opacity = 0

Esta linea lo que hace es volver transparente el fondo de la ventana, dejando los bordes y el contenido de la misma con opacidad normal, ahora haz algunas pruebas cambiando la opacidad de tus ventanas y testeandola en tu juego.

Ahora volvamos al editor de script en la ventana Window_Item para cambiar la linea anterior y poner esta nueva linea de script:

Code:

self.opacity = 0

Esta linea de script volvera transparente incluso el brode de la ventana, podran probar y verlo ustedes mismos si lo prueban en su juego, solo prueben un poco para ver que pasa.

V. Conclusión

Espero que hayan captado todo lo que he dicho, y si no, no te preocupes en absoluto. Sólo leer el tutorial es una tarea muy ardua y compleja. Si tienes alguna pregunta, por favor, publicalo. Ahora un resumen de lo que has aprendido:

     Los métodos de dibujo es una utilidad que se puede utilizar para mostrar un montón de información sobre la ventana, como HP, SP, exp, etc

     El metodo para mostrar imágenes utilizando el método de draw_picture y cambiar sus valores X e Y en el método de actualización de la ventana.

    El metodo para cambiar la opacidad de las ventanas de dos maneras distintas. Una forma es utilizando el código self.back_opacity que afecta a la opacidad de una ventana a excepción del borde a su alrededor. La otra forma es el código self.opacity que cambia la opacidad de todo en la ventana.

Basic Windows

2012-04-09T13:54:00.001-07:00

Este tutorial fue traducido desde esta pagina.
Traducido por tenshi98

Basic Windows

I. Introducción
II. La historia de la creación de ventana
III. Herencia
IV. Set-Up
V. Hacer Nuestra ventana
VI. Mostrar Nuestra ventana
VII. Agregar contenido a nuestra ventana
VIII. Conclusión

I. Introducción

Hola a todos: D Este es el primer tutorial de los varios que serán creados por los constructores de Script. En este tutorial, vamos a estar ayudando a que ustedes se familiaricen con las Ventanas. Al final de este tutorial, deben de ser capaz de crear sus propias ventanas, que pueden mostrar texto y que se puede recurrir a una vez que interactúan con un evento. Voy a poner mi mejor esfuerzo para explicar el funcionamiento del script en este tutorial, pero si no lo hago, por favor tengan paciencia conmigo :)

II. La historia de la creación de ventana

Puede que no lo sepas, pero las ventanas son uno de los aspectos más vitales de RPG Maker XP. Sin ventanas no existiria un menú, un sistema de mensajes, HUD, tiendas y ect. Básicamente, para explicar lo que las ventanas son, en pocas palabras, son las superficies que se pueden dibujar información sobre ellas. En RGSS, hay dos tipos de ventanas: Window_Base y Window_Selectable. Vamos a pensar en ello como esto: Había una vez, un hombre llamado Ventana. Se estaba poniendo viejo y deseaba tener un hijo. Por lo tanto, decidió casarse con una dama llamada Sintaxis, y poco después, tuvo un hijo llamado Window_Base. Window_Base se planteó adecuadamente por sus padres amorosos y pronto se casó y tuvo varios hijos, como Window_Gold, Window_Menustatus, y mucho más. Pero uno de los niños fue ... raro. Su nombre era Window_Selectable y llevaba rasgos adicionales además de los que su madre, su padre y sus hermanos llevaban. Él fue capaz de crear selecciones en las ventanas que él creó. Su familia le repudio por sus anomalías y la Window_Selctable triste se fue y se casó para recuperar su felicidad. Él tuvo varios hijos, así que llevó a sus características. Sus hijos incluidos Window_Command, Window_ShopCommand, y mucho más. Así que ... ¿cómo lo sé? ¿A quién creo que soy yo para decir a ustedes quién es el padre Window_Selectable es o no de Window_Base? Bueno, eso es porque no tengo pruebas.

III. Herencia

Abra un proyecto de RMXP vacío y pulse F11 para abrir el editor de script. Desplácese hacia abajo para en Window_Base y haga clic en él. En la línea 7 se vera algo parecido a esto:

Code:

class Window_Base < Window

Esta línea de código nos dice que Window_Base es hijo de Window, o Window_Base es una subclase de Window. Si nos fijamos en el script de Window_Gold, verá algo similar en la línea 7:

Code:

class Window_Gold < Window_Base

Esto demuestra que la clase Window_Gold es una subclase de Window_Base. Cuando una clase es una subclase, hereda todos los mismos métodos de la clase Padre. Básicamente,la subclase sera igual a la clase, más las nuevas características que usted mismo puede definir.

IV. Set-Up

Estoy bastante seguro de que he aburrido bastante a ustedes que la gran cantidad de texto, pero ahora finalmente vamos a saber del código 

Bien, en primer lugar, tenemos que hacer una nueva página en blanco en el editor de script. Si no lo ha hecho, hacer un proyecto RMXP nuevo y pulse F11 para abrir el editor de script. Desplácese hasta el final de la lista de script, en el Main. Haga clic en él y pulsa Insertar. Ahora deberías ver un espacio en blanco por encima de principal, haga clic en él. Ahora mira hacia abajo en principal y usted debería ver un espacio en blanco donde se puede escribir. Allí, escriba el título de nuestro nuevo script: Custom Text Window. Después de dar el nombre a su ventana, a la derecha, debe haber una hoja blanca de gran espacio para poder comenzar a escribir el scrpit. Antes de empezar, tenemos que saber quién es el padre o la super clase de nuestro script va a ser. Desde esta ventana solo vamos a mostrar información y no va tener opciones para que usted elija, a continuación, la superclase de esta ventana va a ser Window_Base. Ahora, es el momento para que te dé el esquema que normalmente se utiliza al realizar un script de ventana que es una subclase de Window_Base:

Code:

#==============================================================================

# ** 

#------------------------------------------------------------------------------

#  

#==============================================================================

class 

#--------------------------------------------------------------------------

# * Object Initialization

#--------------------------------------------------------------------------

def initialize

super(x, y, width, height)

self.contents = Bitmap.new(width - 32, height - 32)

refresh

end

#--------------------------------------------------------------------------

# * Refresh

#--------------------------------------------------------------------------

def refresh

self.contents.clear

end

end

En primer lugar copiar este esquema en un archivo de bloc de notas en blanco y lo llaman Window Outline. Debes hacer esto para que puedas copiar este esquema desde el bloc de notas cada vez que lo necesites. Ahora, copia este esquema en el interior de la clase recien creada (la que hablamos anteriormente) en la hoja en blanco de esta. Si lo hiciste correctamente deberia quedar de la siguiente manera:

V. Hacer Nuestra ventana

En primer lugar, vamos a empezar con las líneas 1 a 5 del script. El símbolo # significa que el resto de la línea será un comentario. Los comentarios no cambiar el resultado de un script, su único propósito es ayudar a la gente a entender mejor lel script. Hagan su mejor esfuerzo para comentar a menudo, pero no todo el tiempo. Pues bien, vemos que en la línea 2, hay un símbolo de comentario y acompañado de dos asteriscos. Aquí va el nombre de nuestra clase de ventana. La vamos a llamar Window_Text. Ahora, en la línea 4, también debe ser un símbolo de comentario. Aquí, vamos a escribir la descripción de nuestra clase. Algo asi como "Este texto aparece en una clase de ventana". Ahora bajamos a la línea que comienza con la clase. Class es una palabra clave en Ruby / RGSS. Es la palabra clave que se utiliza cada vez que se define una clase. Dado que en nuestros comentarios, nos dice que el nombre de la clase iba a ser Window_Text y ya dijimos que esta ventana va a ser heredado de Window_Base ya que sólo muestra la información, esta línea debería tener este aspecto:

Code:

Class Window_Text < Window_Base

Bueno, ahora tenemos todo el script bajo esa clase, vamos a pasar a los métodos del script :)

En primer lugar, que es un método? Bueno, en Rubí / RGSS un método es básicamente un bloque de código que se puede llamar fuera de una clase. Un ejemplo sería algo así como:

Code:

def stop_print

print “Hello” unless Input.tigger?(Input::A)

end

Lo que este método simplemente hace es imprimir "Hola" siempre que el botón A se pulse. La forma de llamar a un método en el script es escribir su nombre. Algo así como:

Code:

def print_things

print “Hey”

print “World”

stop_print

print “What”

end

Lo que sucede aquí es que imprimiremos el texto hasta llegar a stop_print que nos da la opción de pulsar A y no imprimir esa línea de texto.

Ahora, que tenemos una comprensión básica de los métodos, volvamos a nuestro código, ¿de acuerdo?

El método initialize esta en cada clase de ventana. Basta con mirar los script de Window_Gold Window_PlayTime y te darás cuenta de que el método initialize esta en los dos. El método de inicialización define las propiedades de la ventana. La primera línea de este bloque de código dice lo siguiente:

Code:

def initialize

Esto sólo nos dice que estamos haciendo un método llamado initialize.

A continuación tenemos la línea que comienza con el super. Super es una palabra clave que llama a un método de la clase que hereda de esta clase(la clase padre). Así que, básicamente, en este caso, es una llamada al método initialize de la clase Window_Base para que podamos definir la coordenada x, la coordenada y, la anchura y la altura de nuestra ventana nueva. Puesto que esto va a actuar como una ventana de texto normal, vamos a establecer la coordenada x en 0, la coordenada y 320, el ancho de 640 y la altura 160. Trata de jugar con estos valores para que pueda obtener una mejor comprensión de la manipulación de las propiedades de la ventana.

A continuación tenemos una línea que comienza con self.contents. Esta línea, básicamente, sólo se inicializa la ventana de los valores que acaba de poner y crea un mapa de bits fuera de él. Después de eso, nuestro método de actualización es llamado y terminado con la palabra clave end. El script debería tener este aspecto a partir de ahora:

VI. Mostrar Nuestra ventana

Bien, ahora vamos a ver lo que hemos hecho hasta ahora. Pulse OK en la ventana del editor de script para cerrarlo. Ahora, presione F8 para que su capa de eventos (mapa). Haga doble clic en una ficha al azar para abrir la ventana de eventos. Haga doble clic en el cuadro bajo que el de abrir la lista de los gráficos de los personajes. Elija la segunda opcion llamada 002-Fighter02 y aceptar. Ahora, ve a la derecha de la ventana del evento, en la lista de los comandos del eventos y haga doble clic en cualquier espacio al azar para abrir la ventana de comandos de eventos. Ir a la página tres y haga clic en el último comando que dice "llamar script ... '. Ahora en la ventana Script. Copia este trozo de código en:

Code:

$window = Window_Text.new

Después de esto, pulsa Aceptar y a continuación vuelve a ingresar otro evento, esta vez le pondremos un esperar 40 frames, le das aceptar y nuevamente te vas al ultimo comando que dice llamar script, alli le pones la siguiente linea de codigo:

Code:

$window.dispose

A continuación, pulse Aceptar y revise para ver si la ventana de su Case se parece a esto:

Ahora que ha terminado, pulse OK en la ventana de su Case para cerrar fuera de él y pulse F12 para probar ejecutar nuestro proyecto. Asegúrese de guardar si se le solicita.

Ir hasta el evento que acaba de hacer y pulse el botón de acción en él. Una ventana debe aparecer en la parte inferior de la pantalla y desaparecen después de unos 2 segundos. Si ese es el caso, vamos a continuar con este tutorial, si no, trate de volver a leer el tutorial de la parte que empezamos a crear nuestro evento en.

VII. Agregar contenido a nuestra ventana

Ahora es hora del último paso de nuestro tutorial. Tenemos que editar nuestro método de actualización. Abre el editor de script (F11) de nuevo e ir a la línea 19 de nuestro script. Ya hemos hablado de lo que este tipo de líneas son, sino que basta con utilizar la palabra clave def para demostrar que estamos definiendo un método y luego le da el nombre del método que en este caso es "Refresh". En la siguiente línea, tenemos algo que se parece a esto:

Code:

self.contents.clear

Esta línea simplemente borra de nuestro mapa de bits / ventana que se ha hecho, para que podamos empezar a dibujar un poco de texto. Ahora, añadimos una nueva línea después de esta línea pulsando enter al final de ella y copiar esta línea de código en:

Code:

self.contents.draw_text(0, 0, 100, 100, "Hello World")

Esta línea nos dice que vamos a dibujar el texto en la ventana. Los valores en los paréntesis que van de izquierda a derecha, la coordenada x, la coordenada y, la anchura, la altura, y, finalmente, la cadena de texto. Trate de jugar con estos valores para acostumbrarse a lo que hace. A continuación, agregue estas líneas de código después de la que acabamos de agregar:

Code:

self.contents.font.color = system_color

self.contents.draw_text(150, 0, 100, 100, "Hello World")

self.contents.font.color = knockout_color

self.contents.draw_text(300, 0, 100, 100, "Hello World")

self.contents.font.color = crisis_color

self.contents.draw_text(450, 0, 100, 100, "Hello World")

En la primera línea de este código, hemos cambiado el color de nuestra siguiente cadena de texto a "system_color", que es como un color azulado. Después de eso, se añade otra cadena de texto que también dice: "Hello World", pero ahora en una coordenada x de 150. La siguiente línea después de esto, podemos cambiar nuestro color de fuente a "knockout_color", que es un color rojo. Al igual que antes, se añade otra cadena de texto que también dice: "Hello World", pero ahora está en una coordenada x de 300. Por último, podemos cambiar nuestro color de la fuente a la crisis_color que es un color amarillo. Después de esto, nos basamos nuestra cadena final de nuestro "Hello World" en el texto de una coordenada x de 450. Además, como nota al margen, para saber qué tipo de colores que puede utilizar para su tipo de letra, basta con ir a la secuencia de comandos Window_Base y la mirada en las líneas 61 a la 90.

Su ventana del editor de script debería tener este aspecto:

Ahora vamos a guardar nuestro proyecto y probar ejecutar nuestro juego (F12). Activa ese evento que hemos creado y pulse el botón de acción para revelar la ventana nos hemos basado en. Debe tener este aspecto:

Si puede ver esta ventana, entonces hemos realizado con exito nuestra primera ventana.

VIII. Conclusión

Con suerte, yo he sido lo suficientemente claro en este tutorial para que ustedes puedan seguirlo con facilidad, si no, me disculpo. Esperemos que hayan aprendido mucho acerca de las ventanas de este tutorial, definitivamente habrá más tutoriales acerca de las ventanas en un futuro próximo, tales como la adición de imágenes. Gracias a todos por su tiempo en leer este tutorial.

Tutorial de minas

2012-04-07T18:42:00.001-07:00

Notas preliminares : tengan en cuenta que este engine esta integrado a este sistema, asi que al descargar el ejemplo, de paso tambien se descargan el sistema.

En esta clase enseñare como crear una mina y poder detonarla a distancia, comenzaremos creando un evento comun en donde crearemos 2 variables para guardar la posicion x-y del personaje, estas nos serviran para decirle al evento mina donde ubicarse, a estas variables las llamaremos mina x y mina y.

Despues le indicamos que espere 5 frames y que active un interruptor que crearemos con el nombre de mina lanzada, nuestro evento quedaria asi por el momento:

Ahora nos vamos al mapa a crear la mina, recuerden que este evento tendra que estar siempre presente en los mapas que hagan para que puedan ocuparlo
En la primera hoja en condiciones de aparicion seleccionamos el interruptor mina lanzada, en detonante de inicio lo dejamos en proceso paralelo, dentro del evento le ponemos un elegir posicion de evento segun las variables Mina x y Mina y, despues le damos un esperar 5 frames y que active un interruptor que crearemos con el nombre de Mina activa.

En la segunda hoja de este mismo evento le ponemos en condiciones de aparicion seleccionamos el interruptor Mina activa, en detonante de inicio lo dejamos en proceso paralelo,marcamos la opcion de animacion parado y atravesable, tambien seleccionamos algun grafico de mina, dentro del evento le ponemos algun sonido acorde y le damos esperar x frames (ustedes deberan ajustar los frames de acuerdo a la animacion del grafico, aunque es solo opcional), esto hara que el sonido se repita constantemente.

Ya con esto volvemos a los eventos comunes y ponemos un condiciones y efectos revisando si el interruptor Mina activa esta encendido, trasladamos lo que habiamos puesto anteriormente dentro de la excepcion de esta condicion, en la condicion true ponemos que queremos activar el interruptor que crearemos con el nombre de mina explotando.

Ya con esto listo tenemos que ir a PP - Sistema para poder asignarle su tecla corresondiente (w) para su uso:

Vamos al mapa y entramos nuevamente al evento mina, le creamos una tercera hoja y le ponemos en condiciones de aparicion seleccionamos el interruptor Mina explotando, en detonante de inicio lo dejamos en proceso paralelo, dentro del evento le ponemos algun sonido y algun tiempo de espera, tambien le ponemos que desactive todos los interruptores usados para la mina:

Aceptamos y testeamos, al presionar w la primera vez aparece la mina, al presionarlo por segunda explota, pero no pasa nada, esto es porque aun no hemos definido que pasara al momento de la explosion: podemos hacer dos cosas, la primera seria hacer que el evento mina calcule todas las posiciones de los enemigos, determinando el area, viendo quienes estan dentro y hacerles daño, basicamente lo mas obvio pero no lo mas optimo, ya que si configuras el evento mina para 10 enemigos, y solo hay 3, la mina calculara las posiciones de los 10 enemigos; este calculo en un computador de ahora no se nota, pero en un pc mas o menos antiguo crea lag, lo mas optimo es ponerle el calculo del area al mismo evento enemigo, que sea este el que calcule que tan cerca esta del evento mina, esto permite que solo los eventos enemigos presentes en el mapa realicen el calculo, disminuyendo el posible lag.

Despues de tanta explicacion, pasare a mostrarles como realizarlo, primero abren el evento enemigo, en la primera hoja copian todo, ahora crean una nueva hoja y le pegan todo, en condiciones de aparicion le ponen el interruptor mina explotando y en detonante de inicio le ponen proceso paralelo, ahora en el interior del evento, en las comparaciones ubican las variables de la posicion x-y del personaje y se la cambian por la x-y de la mina, en el interior de todas las condiciones le suman la cantidad que quieran a la variable vida del enemigo (tambien puede ser una cantidad variable) y una animacion acorde:

Ahora testeamos y vemos que funciona perfecto, lo que nos queda por hacer ahora es que verifique si tenemos minas en el inventario, que reste 1 al usarlas y que le haga daño a nuestro personaje, comenzaremos con lo primero:

Primero creamos el item mina si no lo tenemos creado, luego mediante algun evento le das minas (si, bastante basico de hacer) ahora en el evento comun Actualizar balas, sobre todas las condiciones agregas una variable que guarde la cantidad de minas que tengas:

Con esto listo nos vamos al evento comun mina y dentro de la excepcion le ponemos la condicion de que revise si la variable cantidad de minas es superior a 0, dentro le pegamos lo que estaba anteriormente en la excepcion y le agregamos cambiar objetos para que le reste una mina, despues le agregamos un llamar evento comun Actualizar balas para que actualice la nueva cantidad de minas.

Ahora pasaremos a calcular el daño al personaje al estar cerca de la mina, para esto necesitaremos crear 2 variables nuevas para guardar la posicion x-y de la mina, ya que si reutilizamos las que guardan la posicion x-y de la mina intervendremos con el funcionamiento del resto del engine, lo unico que debemos hacer es calcular el area de la mina y verificar si el personaje esta dentro de ella, luego traspasarle el daño al personaje y asignarle una animacion

Ya con todo esto tenemos el engine de mina listo.

Descarga del ejemplo

Engine de Ascensor

2012-04-07T12:58:00.002-07:00

Notas preliminares : tengan en cuenta que este engine esta integrado a este sistema, asi que al descargar el ejemplo, de paso tambien se descargan el sistema.

Hoy comenzaremos con el engine de ascensor, el cual es un poco complicado de hacer, asi que tratare de explicar todo el proceso de creacion:

Primero comenzamos creando un mapa de acuerdo a l que necesitamos:

Despues creamos un evento en el lugar de la puerta, yo ocupe este:

Ya con esto tenemos "el ascensor", ahora hay que poner la animacion del cierre de la puerta (y algun sonido para que quede realista) en un evento aparte, yo puse este evento al lado ya que lo reutilizare despues, este evento quedaria asi:

Al final le puse que activara el interruptor A de ese evento, esto es para activar su segunda hoja, en la cual llamare a las imagenes para conformar el menu de los botones del ascensor, el detonante de inicio sera aceptar, ya que quiero que este se active solo cuando yo lo seleccione, el evento quedaria asi:

Ahora, una cosa que me he dado cuenta, a mayor el numero de imagen, mayor es su prioridad de vista, esto quiere decir que la imagen 3 siempre se va a ver sobre la 2, la 2 sobre la 1, por lo tanto asegurense que la imagen base sea siempre la numero 1, y que los botones sean el resto, al final agrego un activar interruptor local b para pasar a su tercera hoja, que es en donde programaremos la funcion del ascensor:

Comenzamos con la construccion del engine en si:

En la tercera hoja comenzamos seleccionando como detonante de inicio el proceso paralelo, despes en el interior ponemos un asignar teclas, para que guarde el valor de las teclas presionadas dentro de una variable:

Ahora pasaremos a poner las condiciones si presionas hacia arriba o hacia abajo al seleccionar el piso al que quieres ir:

La primera condicion seria si la variable teclas ascensor es igual a 8, o sea, si estas presionando hacia arriba
La segunda condicion tendra que ir en la excepcion de la primera condicion, y verificara si la variable teclas ascensor es igual a 2, osea si estas presionando hacia arriba

Con estas dos condiciones solo tienes dos opciones, presionar hacia arriba o hacia abajo, ahora viene lo complicado de explicar, hacer que otra variable guarde la opcion del piso que estas eligiendo, y que esta reconozca que, por ejemplo, si llegaste al boton 3, pase al 1 automaticamente (en el caso de que tengas solo 3 pisos).

Lo explicare lo mas simple posible:

Al boton 1 del ascensor le asignaremos el valor 0 de la variable
Al boton 2 del ascensor le asignaremos el valor 1 de la variable
Al boton 3 del ascensor le asignaremos el valor 2 de la variable

La condicion que pondremos dentro de las condiciones anteriores sera que si la variable (que llamaremos piso - opciones) es igual a 0, le cambie el valor a 2, en pocas palabras si tienes selecionado el boton 1 y presionas hacia arriba, pase a seleccionar el boton 3, en la excepcion de esta condicion le pondremos que le reste 1 a la variable piso - opciones, ya que por ejemplo, podemos tener seleccionado el boton 2, y al presionar el boton hacia arriba el valor de la variable no sera 0, sino que sera 1, y como queremos ir al boton 1, necesitamos restarle valores, no reemplazarlo; se que me he complicado un poco, asi que mejor les pongo una captura:

Si lo probamos ahora, no va a pasar nada, ya que el engine no hace nada en relacion a las imagenes, asi que agregaremos la opcion de que nos muestre el piso que estamos seleccionando, para esto con ayuda de la variable piso - opciones y algunas condiciones modificaremos la opacidad de los botones (tambien se puede llamar a una nueva imagen que haga de cursor, a la cual le podemos modificar la posicion x-y)

Ahora testeamos y vemos que los botones reaccionan a nuestra seleccion, si nos fijamos, el personaje se mueve mientras seleccionamos, debemos crear un evento que lo deje quieto, para eso creamos un nuevo evento en el mapa(seria el tercero), con detonante de inicio proceso paralelo y que lo active un interruptor que vamos a crear y llamar personaje inmovil, dentro del evento le pondremos un mover evento(personaje) y que espere 20 frames, esto hara que al estar este interruptor activo, esperara 20 frames repetidas veces.

Ahora debemos activar este interruptor, lo haremos en el evento que tenemos al lado de la puerta(debi haberle puesto nombres para identificarlos), en su segunda hoja, la que llama a las imagenes, quedaria algo asi:

Ahora tenemos que hacer la parte del engine en donde al presionar aceptar nos lleve al piso seleccionado, para esto tendremos que tener en cuenta lo siguiente:

Saber en que piso te encuentras
Saber a que piso vas
Saber la diferencia de pisos entre el que estas y el que deseas ir
Borrar las imagenes del engine
Desactivar el interruptor personaje inmovil
Desactivar el interruptor local B

Tambien hay que darle valores a cada piso, para que se sepa hacia donde vamos

Piso 1 valor 0
Piso 2 valor 1
Piso 3 valor 2

Teniendo esto claro comenzamos:
Primero comenzamos poniendo una comparacion de la variable tecla, si esta es igual a 13 (tecla C)
dentro borramos todas las imagenes del engine, de la 1 a la 4 y un esperar de unos 20 frames, quedando algo asi:

A continuacion creamos una variable que contenga el piso actual, esta variable debe ser actualizada en la entrada de cada puerta de ascensor, para que ya contenga el piso en que estamos, luego hacemos condicion que compare los valores de las variables del piso, con los valores del piso que elegimos, por ejemplo, si entramos desde el piso 1, el valor de la variable piso actual seria 0, y si seleccionamos que queremos ir al piso 1, el valor de la variable tambien seria de 0, entonces podemos hacer lo siguiente:

Aqui verificamos si estamos en el mismo piso, si no estamos en el mismo piso se ejecutara lo que queramos, si tomamos el ejemplo anterior la verificacion seria que si estamos en el mismo piso, entonces tenemos que simplemente poner la animacion de la apertura de las puertas:

Si fuera el caso contrario , tenemos que hacer que reconozca la cantidad de pisos a recorrer, esto lo haremos con una operacion en donde calcularemos la cantidad de pisos de diferencia, las variables que usaremos seran la del piso actual y la de piso-opciones, revisando cual de las dos es mayor, luego a la variable de mayor cantidad le traspasaremos su valor a una variable temporal y haremos una resta con la variable de menor valor, con esto tendremos la cantidad de pisos a recorer (si, es complicado de entender):

Ahora tenemos que hacer que el ascensor se mueva de piso a piso, y que cuando llegue al piso seleccionado abra las puertas, esto lo haremos co un ciclo y una condicion;

Basicamente lo que hicimos aqui fue preguntar si la variable piso temp era superior a 0, mientras el resultado fuera verdadero, sacudiria la pantalla y le restaria 1 (es por esto que el resultado de la resta debe ser positivo), cuando llegara a 0 la comprobacion seria falsa, entonces abriria la puerta, ahora solo nos queda desactivar el interruptor personaje inmovil, darle una indicacion al maker de que puede abrir la puerta y desactivar el interruptor local B:

Como ven cree el interruptor Ascensor ok para indicarle al maker mi seleccion del piso, ahora vamos al evento donde tenemos la puerta y le creamos una segunda hoja, en condiciones de aparicion le indicamos que usaremos el interrupor Ascensor ok y en detonante de inicio le ponemos colisionar, seleccionamos el grafico de la puerta abierta y en el interior del evento le ponemos las condiciones que revisen el valor de la variable piso - opciones, y dependiendo de este, que te transporte al mapa deseado:

Con esto ya tenemos listo el engine, testamos y comprobamos que todo vaya bien.

Notas finales: hay un leve retraso entre cuando seleccionamos el piso y cuando podemos mover el pesonaje, eso se arregla modificando los tiempos de espera.

Alternativamente podemos agregar al engine la posibilidad de que se cierren las puertas despues de un tiempo, basta con crear un evento en el mapa con lo siguiente:

Correcciones:hice unas pruebas y encontre 2 pequeños bug:
La puerta solo se cierra la primera vez que entro al ascensor: la solucion es desactivar el inerruptor local A del evento que esta al lado de la puerta, lo desactivas junto con los otros interruptores al presionar la tecla C, en la tercera hoja, esto haria que funcione de nuevo, y pones una condicion en la primera hoja, verificando si el interruptor Ascensor ok esta desactivado:

El otro bug que encontre es relacionado con el piso seleccionado, este se queda con el valor del piso que seleccionamos la ultima vez, para resetearlo a 0 nos vamos a la segunda hoja del mismo evento y le asignamos el valor 0

Con esto funciona perfecto

Descargar el ejemplo

Crear un action rpg y no morir en el intento 8

2012-04-06T22:48:00.000-07:00

Hoy comenzamos con la clase para crear armas de fuego, comenzaremos creando las diferentes tipos de municiones a usar:

Municion Pistola
Municion Escopeta
Municion Rifle francotirador
Municion Rifle de asalto
Municion Metralleta

Las pueden poner en la id que quieran, ahora crearemos un evento comun que se encargara de traspasar las cantidades de las Balas a una variable temporal, para hacer algunas comprobaciones con estas , a este evento lo llamaremos Actualizar balas:

La agrupacion quedara asi:

Arma de fuego 1 y 2 : Municion Pistola
Arma de fuego 3 y 4 : Municion Escopeta
Arma de fuego 5 y 6 : Municion Rifle francotirador
Arma de fuego 7 y 8 : Municion Rifle de asalto
Arma de fuego 9 y 10 : Municion Metralleta

Ahora tenemos que crear 10 variables que nos serviran como cartuchos:

Despues le podran cambiar el nombre a las variables, dandole el nombre correspondiente al arma, ahora volvemos al evento Actualizar balas y agregamos las variables recien creadas, tambien traspasandola a una variable temporal, ustedes se preguntan el porque de esto, es para el hud que haremos mas adelante, ya que solo tendremos que solicitar los valores a las variables temporales en vez de hacer una busqueda arma por arma, el evento quedaria asi:

Ahora tendremos que ir a los eventos Direccion Fija y Guardia y agregamos las armas de fuego (en la clase anterior vimos para que servia cada evento), tambien en el evento que activa el sistema agregamos las armas y los items recien creados, para poder hacer las pruebas.

Ahora lo siguiente es importante, por cada arma hay que crear un evento de disparo y otro de recarga del arma, comenzaremos detallando el de recarga:

Primero dependiendo de la direccion en que mire, le ponemos la animacion, esta en el ultimo mover evento, tiene que volver a la posicion guardia del arma correspondiente, por ejemplo, si le pones una pistola, al estar en guardia, sera en guardia-pistola; si recarga sera en recarga-pistola, y el ultimo mover evento (cambio de grafico) sera guardia-pistola, no otro, sino quedara mal.

Despues en el mismo evento le ponemos un esperar de 16 frames (los esperar entre cada cambio de grafico), despues le ponemos las siguientes condiciones:

poner una etiqueta (cualquier valor)
Comprobar que la municion del cartucho sea inferior al maximo que puede llevar
Comprobar que los item guardados sean superior a 0
sumarle 1 a la variable del cartucho
restar 1 a los items del arma correspondiente
llamar al evento comun Actualizar balas
poner un ir a etiqueta para crear ciclo

Esto basicamente muestra la animacion de recarga y luego repite el ciclo hasta que el cartucho este lleno, como veran, el cartucho tiene una capacidad de 15 balas.Alternativamente podemos ponerle algunos sonidos de cambio y recarga.

Despues pasamos a hacer el evento comun del disparo revisando lo siguiente:

Comprobar que la municion del cartucho sea superior a 0(mediante la variable temporal)
activar interruptor de ataque_cuerpo (en serio, hay que cambiarle el nombre)
llamar al evento comun de la bala, para que haga el recorrido
restarle 1 al cartucho del arma
actualizar la variable temporal con el valor actual del cartucho

Alternativamente se puede agregar una excepcion que llame automaticamente al evento recargar en caso de que el cartucho llegue a 0.

Ahora, solo tenemos que agregarlo al evento comun Seleccion arma para que pueda disparar, quedaria algo asi:

Ahora tenemos que crear un evento comun para la recarga del arma, sera igual que siempre, dependiendo del arma equipada:

Una vez listo hay que agregarlo a la combinacion de teclas, quedando algo asi:

Armas de fuego
Z-Guardia
Z+X-Recarga
Z+C-Disparo

Ahora testeamos el proyecto.

Con eso ya terminamos la clase, podemos ocupar el engine de disparo del enemigo que mostre en el capitulo anterior para aplicarlo a esto.

Despues de testear encontramos el error de que cuando el personaje recarga municion, los enemigos se quedan quietos, esto pasa porque el interruptor ataque_cuerpo se queda activado, solucion, desactivarlo en la excepcion del disparo, antes del sonido "sin municion" de todos los eventos comunes de disparo.

Descarga del ejemplo.

Crear un action rpg y no morir en el intento 7

2012-04-06T19:10:00.001-07:00

Comenzaremos primero con el cambio de gráfico de la flecha, porque asumo que se dieron cuenta que al usar un arma cuerpo a cuerpo, la flecha igual aparecía, ahora condicionaremos su aparición de acuerdo al arma que tenga equipada el personaje:

Primero creamos un nuevo evento común con el nombre Gráfico Flecha , luego le ponemos condiciones y efectos de las armas equipadas que queremos que cambie el grafico, estas condiciones deben estar anidadas, quedaría algo así:

Ahora tenemos que poner que cambie el gráfico dependiendo de donde mire el personaje dentro de cada condición, exactamente como lo hicimos con el evento de la flecha que tenemos en el mapa, ustedes se preguntaran para que hacer esto, pues de esta manera podemos asignarle distintos tráficos a la flecha en el caso de que se quiera usar mas de un tipo de flecha. esto quedaría así:

Bien, con esto podríamos decir que ya esta listo, pero podemos anidar las condiciones, de esta manera nos ahorramos una condición, descargando un poco el trabajo del maker, esto quedaría así:

Ustedes se preguntan que acabo de hacer, les explico de manera simple:

Si el personaje mira hacia abajo : xxxx
Si el personaje mira hacia la izquierda : xxxx
Si el personaje mira hacia la derecha : xxxx
Si el personaje no mira en ninguna de las direcciones anteriores : xxxx

Simple, verdad, ahora hay que editar el evento flecha, agregandole un llamar evento común haciendo referencia al evento recién creado, y quitar el grafico que tiene puesto, ya que este cambiaria automaticamente al llamar al evento común, esto quedaría así:

Bien, con esto estamos listos, el engine lo testeamos y probamos que no tenga ningún bug.

Ahora seguimos con la opción de que el enemigo también nos pueda disparar, primero seleccionamos el evento enemigo, vamos en la segunda pestaña y luego presionamos nueva hoja, para que nos cree una nueva en la posición 3 (no es necesario, solo es para mantener el orden), dentro de esta seleccionamos el gráfico y en detonante de inicio le ponemos proceso paralelo.

Bien con esto listo ahora debemos hacer la IA para que el enemigo:

Siga al personaje.
Una vez dentro del área de tiro se mueva hacia los lados para centrar el objetivo.
Disparar una vez que el personaje este dentro del rango de disparo.

Primero vamos a movimiento autónomo, y le ponemos ruta, en crear ruta le ponemos unas 8 o 9 veces que siga al personaje, ya con esto ya logramos que siga al personaje, después creamos una condición, la cual revisara si el interruptor local B esta apagado, después vamos a la primera pestaña y copiamos las variables que calcula que el personaje esta dentro del área, ya que esta vez le vamos a dar una utilidad distinta, y la pegamos en la excepción de la condición que pusimos en la hoja 3, luego modificamos el interruptor local A On a Interruptor Local B On, después antes de activar el interruptor insertamos un mover evento, en donde especificamos que este evento (el enemigo) debe esperar 20 frames. Ustedes se preguntan que hemos hecho con con esto, simple, el evento te seguirá siempre, pero cuando entres a su rango siempre se detendrá, si lo hiciste correctamente te quedaría algo así:

Ahora testeamos que el evento nos siga y se detenga a la distancia de 6 cuadros.
Ya con esto continuamos, ahora tenemos que hacer que el enemigo ubique al personaje y se mueva de acuerdo a la posición que tenga, para esto, en la excepción de condiciones y efectos : interruptor local B = off, luego ponemos un condiciones y efectos : este evento mirando dirección y creamos una variable en donde guardaremos la posición en que el evento esta mirando

Abajo=1
Izquierda=2
Derecha=3
Arriba=4

Luego volvemos a guardar la posición x-y del enemigo para asegurarnos que tenemos los datos correctos al hacer los cálculos.

después hacemos una comparacion de las posiciones, por ejemplo si mira hacia abajo, hacemos una comparacion solo del eje x(para que se mueva a los lados, para centrar el objetivo), hacemos el calculo si el valor es mayor o menor, dependiendo de eso es si se mueve a la derecha o a la izquierda:

Luego en la excepción de ambas comparaciones,creamos dos variables y traspasamos la posición x-y del enemigo a la bala:

Luego creamos y activamos el interruptor del enemigo disparando:

Después vamos a los eventos comunes y creamos el evento Bala enemigo 1,y dentro hacemos la comparacion de dependiendo de hacia donde mire el enemigo (la variable de dirección), le sumamos y restamos valores, con 1 frame de tiempo de espera (como con la bala del héroe)dependiendo de hacia donde mire, y desactivamos el interruptor en_atack:

Luego volvemos al evento enemigo y después de activar el interruptor en atack ponemos un llamar evento común:Bala enemigo 1,luego un esperar 10 frame (no queremos que nos acribillen) y desactivamos el interruptor local B.

El evento completo debería quedar así:

Ahora creamos otro evento común, que se active con el interruptor En_atack, en proceso en paralelo, que revise si las variables x-y del personaje son iguales a las x-y de la bala del enemigo, se le asigna la animación , el daño al personaje y se desactiva el interruptor En_atack:

Ya con esto, debería funcionar, alternativamente se le puede poner el gráfico de una bala, como lo hicimos con el personaje, les dejo las imagenes del evento que hice:

Con esto doy por terminada la unidad, ya saben, cualquier bug o mejora me la pueden decir.

Descarga del ejemplo

Crear un action rpg y no morir en el intento 6

2012-04-06T13:19:00.000-07:00

Ahora crearemos el sistema de armas a distancia:

Primero comenzaremos cambiando la utilizacion de las teclas, de ahora en adelante usaremos combinaciones, quedando algo asi

Espada:
Z+C - ataque

Armas a distancia:
Z+C - ataque

Quedando algo asi:

Ahora, alternativamente podemos crear un evento comun que bloquee la direccion en que mira el personaje, esto es para tener mas comodidad al disparar, este evento quedaria asi:

Tambien alternativamente, pueden poner un evento que cambie el grafico del personaje, al presionar la tecla Z, para que muestre que se pone en guardia con el arma o algo asi, el evento quedaria de esta manera:

Ahora tenemos que agregar estos dos eventos en Sistema para que funcionen. ambos eventos deben ir en el interior de la condicion y efectos : pulsar tecla Z para que funcionen correctamente, quedando algo asi:

Ahora testeamos, primero con las armas cuerpo a cuerpo, veremos que no pasa nada, pero al equipar las armas a distancia, cambia el grafico al presionar la tecla Z, y aparte se queda mirando en una direccion, pero al dejar de presionarlo, tenemos el problema que se queda mirando solo en una direccion y con el grafico cambiado sin volver a la normalidad, esto pasa porque no hemos agregado la excepcion de presionar la tecla Z, alli pondremos que vuelva a la normalidad:

Testeamos y comprobamos que el engine funciona correctamente, ahora, una recomendacion mia, si van a ocupar ambas opciones, fucionenlas en un solo evento comun, ya que ambas hacen la misma comprobacion del arma equipada, si lo hacen solo tendrian que llamar a un solo evento comun, sin sobrecargar al maker, quedaria algo asi:

Ya tenemos el cambio de grafico, ahora tenemos que crear el evento bala, para esto reocuparemos algunas cosas que ya teniamos hechas, tambien hay que tener en cuenta la distancia de ataque de cada arma a distancia, para saber cuantos eventos bala hay que crear, para esto tomaremos el evento Calculo area de ataque (evento comun 4) y lo copiaremos 4 veces, ocupando los espacios 8 al 11 de los eventos comunes, ahora asignaremos la funcionalidad de cada uno:

Evento 8 : servira para el ataque cuerpo a cuerpo, lo dejaremos tal cual como esta
Evento 9 : servira para las armas cuerpo a cuerpo con un rango mas amplio de ataque, por ejemplo la lanza, o alguna otra cosa que ustedes hayan creado, este tendra un rango de 2, por lo tanto, hay que sumarle 1 dos veces a las variables de ataque.
Evento 10 : le pondremos 5 cuadros de rango
Evento 11 : le pondremos 8 cuadros de rango

Cambiaremos la distancia del rango de ataque de la siguiente manera:

Si se dan cuenta de lo que hice, le sume de uno en uno los valores del avance, con un lapso de 1 frame entre cada operacion para que el maker no lo sume los valores de golpe, esto se hace por cada direccion que este mirando el personaje, ahora, si quieren le pueden cambiar los nmbres a los eventos para poder identificarlos, yo los deje de la siguiente manera:

Evento 8 : Bala x 1
Evento 9 : Bala x 2
Evento 10 : Bala x 5
Evento 11 : Bala x 8

Ahora tenemos que ir nuevamente a Sistema y eliminar la llamada al evento Calculo area ataque, ya que cada arma tendra su propio rango de ataque, tambien eliminaremos el evento Calculo area ataque, debido a que no lo ocuparemos mas.Despues de eliminarlo tenemos que ir al evento Seleccion arma para agregar los eventos bala a cada arma de acuerdo a su rango de ataque.

Para la espada quedaria algo asi:

Para la lanza quedaria algo asi:

Y para las armas a distancia quedaria algo asi (seleccionando si el rango es de 5 u 8)

Ahora, al testear vemos que no funciona, que algo anda mal, lo que pasa es que el evento enemigo esta desactivando automaticamente el interruptor ataque cuerpo, lo que tenemos que hacer (aparte de cambiarle el nombre...) es quitarlo del evento enemigo, una captura para que se den cuenta de lo que digo:

Lo que esta seleccionado es lo que tenemos que eliminar el evento enemigo, esta desactivacion tenemos que ponerla en el interior de los eventos bala, para que estas, al terminar su recorrido, se desactiven solas, quedaria algo asi:

Ahora volvemos a testear y vemos que el engine funciona perfectamente, ahora veremos como poner el grafico de la flecha en el mapa.

Primero crean un evento en el mapa, que tenga 2 hojas, en la primera hoja en detonante inicio ponen proceso paralelo, y dentro ponen elegir posicion de evento : este evento(variable que guarda posicion x-y del personaje), quedando algo asi:

En la segunda en condiciones de aparacion, seleccionan el interruptor ataque_cuerpo, en el grafico seleccionan la flecha, y en detonante inicio ponen proceso paralelo, luego dentro ponen elegir posicion de evento : este evento(variable que guarda posicion x-y la bala) y tambien que dependiendo hacia donde mire el personaje, cambie el grafico de la flecha (hacia donde mira la flecha), quedando algo asi :

Ya con esto tienen su flecha lista.

Como ven, durante el curso abarcamos:

crear sistema
implementar mas de un arma
establecer la distancia de ataque por separado para cada arma

Proximo curso:

Los enemigos tambien disparan con armas a distancia.
Hacer que el grafico de la flecha cambie de acuerdo al arma equipada.

Descarga del ejemplo

Crear un action rpg y no morir en el intento - intermedio

2012-04-05T16:28:00.001-07:00

Bueno, hago esto por varias cosas que me quedaron fuera en los tutoriales anteriores:

1.-Anidar condiciones:

-Primero:elimine todas las armas que venian por defecto, hice nuevas y las agrupe de la siguiente manera:

10 armas cuerpo a cuerpo
10 armas a distancia
10 armas de fuego

las cuales las subdividi en el tipo de elemento (no es obligatorio, ustedes pueden poner lo que quieran) y el rango de ataque (que es lo que veremos en la proxima unidad); ahora, voy a enseñar un concepto que se llama anidar condiciones, y es para optimizar el tiempo de respuesta del engine, ya que con 30 armas va a producir algo de lag, ahora pasare a explicarle lo que significa anidar:

condicion 1
   respuesta 1
fin condicion 1

condicion 2
   respuesta 2
fin condicion 2

condicion 3
   respuesta 3
fin condicion 3

condicion 4
   respuesta 4
fin condicion 4
imaginen que hacen un proceso, y que necesitan poner la condicion necesaria para obtener un resultado, el maker por defecto leera desde arriba hacia abajo todas las condiciones, no importando si encontro el resultado al principio o al final, osea, si necesitaban el resultado 1, se va a demorar lo mismo que si necesitaban el resultado 4, ahora les mostrare el ejercicio anterior pero anidado:

condicion 1
   respuesta 1
excepcion
condicion 2
   respuesta 2
excepcion
condicion 3
   respuesta 3
excepcion
condicion 4
   respuesta 4
excepcion
etc

fin condicion 4
fin condicion 3

fin condicion 2
fin condicion 1

Ahora al correr de nuevo el proceso, al encontrar el resultado que queremos, saldra de las condiciones automaticamente, esto quiere decir que correra el proceso solo hasta obtener el resultado.

ahora hay que modificar el eneto comun Animacion ataque y en Seleccion arma con este nuevo metodo (en el ejemplo ya esta listo)

Ejemplo:

2.-Explicacion de rango:

En el capitulo 5 casi no explique lo que se estaba haciendo, solo los mas avanzados en el maker lo entendieron, ahora les explicare de manera simple lo que estaba haciendo:

Anteriormente vieron esta imagen, pero esto no significa nada para ustedes, lo que hice fue crear 4 variables, las llamaremos variables 1,2,3 y 4, estas guardan inicialmente la posicion x-y del personaje, luego se le suman y restan valores respectivamente para crear un area alrededor del evento, supongamos:
1 y 2 son para guardar posicion x
3 y 4 son para guardar posicion y
A 1 y 3 le sumo 2
A 2 y 4 le resto 2
y las 4 parten desde la posicion del evento quedaria un area asi:

Ahora, despues de unos comentarios de Wecoc y Lampard, tuve la idea de en vez de ocupar 4 variables nuevas, ocupar las variables x-y propias del evento enemigo para hacer el calculo del area, quedando el evento asi:

Hace exactamente lo mismo que el evento anterior (el de las 4 variables) y reutilizo 2 variables ya utilizadas, ya con esto me ahorro 100 variables que tendria que haber ocupado para los 25 enemigos por mapa que tengo planeado para el juego..

3.-Cambio de variables donde se guardan los parametros del enemigo:

Con el fin de poder poner 25 enemigos por mapa, cambiare la posicion de las variables, originalmente los datos de los enemigos se guadaban hacia abajo, ahora se guardaran hacia al lado, si no me entienden les dejo unas capturas:

Y esas son todas las cosas que al parecer me quedaron fuera, cualquier cosa, la afinaremos durante la proxima unidad.

Descarga del ejemplo

Tutorial de salto

2012-04-05T05:38:00.000-07:00

En este tutorial voy a explicar como hacer un engine de Salto, es algo muy sencillo, sin embargo hay personas que no saben hacerlo o porque apenas están empezando con el maker, o porque no lo han intentado, solo se necesita un poco de conocimiento básico, manejo de “condiciones y efectos” y manejo de eventos comunes…

Bueno, empezando con el tutorial, primero debes ir a la base de datos, y abrir la pestaña “eventos comunes”, crear allí un evento llamado “salto”, aunque puedes llamarlo como quieras, pero yo en este tutorial lo llamaré “Salto”, luego, en la opción que dice “iniciador”, poner “proceso paralelo“

Una vez hecho esto, poner un interruptor de condición llamado “saltar”, aunque igual puedes llamarlo como quieras:

Ahora comencemos con el evento, no es nada del otro mundo, de hecho, es un evento muy sencillo, primero creas operación de “condiciones y efectos”, con la excepción activada, ir a la pestaña 4, activar la opción “tecla” y elegir la tecla “D”:

Esto crea una condición que dice que cuando está presionada la tecla “D”, pasará algo, y la excepción está para que no pase nada cuando la tecla “D” no está presionada:

Ahora debes crear otra condición dentro de ésta con la excepción activada, ir de nuevo a la pestaña 4, activar otra vez la opción “tecla”, pero esta vez elegir la tecla “abajo”, dentro de ésta última condición crear un comando “mover evento”, que afecte al “personaje” elegir la acción “saltar”, y aumentar 3 veces la coordenada Y, y debes elegir la opción “ignorar si no se puede”:

Por el momento el evento tiene que ir quedando así:

Ahora hay que crear otra condición dentro de la EXCEPCIÓN de la última condición, ir a la pestaña 4, activar la opción “tecla” y elegir la tecla “Arriba”(no olvides dejar todas las condiciones con la excepción activada), dentro de ésta condición crear otro comando “mover evento” igual que el anterior, que afecte al personaje, eligiendo la acción “saltar”, pero esta vez restando 3 en la coordenada Y(no olvides activar “ignorar si no se puede” en estos comandos de “mover evento”), ahora el evento va quedando así:

Tranquilo, ya falta poco, solo hay que terminar todas las direcciones….ahora crea otra condición dentro de la EXCEPCIÓN de la última condición, ve a la pestaña 4, activa la opción “tecla” y elige la tecla “Derecha”, ahora dentro de esta condición crea otro comando “mover evento”, igual que los anteriores, pero esta vez sumando 3 en la coordenada X, y el evento debe verse algo así:

Solo falta la última dirección, crea otra condición dentro de la EXCEPCIÓN de la última condición, ve a la pestaña 4, activa la opción “tecla” y elige la tecla “Izquierda”(siempre con la excepción activada), ahora otro comando “mover evento” dentro de ésta condición, igual que los anteriores, pero esta vez restando 3 en la coordenada X, y ahora, dentro de la EXCEPCIÓN de la última condición, crear otro comando “mover evento”, igual que los anteriores, pero esta vez, dejando las dos coordenadas en “0”, y ahora el evento debe quedar así:

Sólo falta el toque final, crea un comando “esperar” y coloca 10 “frames” dentro de la condición de la tecla “D”, fuera de todas las condiciones de las teclas direccionales, así:

Esto evita que cuando presiones la tecla “D”, el personaje no salte 2 veces

Este es todo el evento, ya tienes creado el engine de salto, solo debes activar el interruptor “Saltar” en el juego para poder saltar cuando presiones la tecla “D”, y cuando desees que el personaje no pueda saltar en algún momento del juego, ya sea porque está hablando o por alguna otra razón, sólo debes desactivar el interruptor “saltar” y volver a activarlo cuando desees que el personaje pueda saltar de nuevo .

ggg

Alias

2012-04-04T07:56:00.000-07:00

Tutorial:	Alias
Date Listed:	2008-06-08
Author:	puppet04

Traductor :Tenshi98

Qué es el alias?
Es un objeto que se crea como un pseudonombre del método (al menos lo que yo puedo entender). Mediante el uso de método alias, se puede reducir el número de líneas del código que se escribe, ya que no es necesario escribir nuevamente el método completo para agregar algunas nuevas variables, constantes, etc.Pero no se puede usar alias con constantes (variables, clases y módulos), variables locales y variables generales.Tu puedes ocupar alias solo en un metodo existente. Por lo general, las personas que son nuevos en el scripting y no saben el uso del método de alias hacen:
a) Editan el script por defecto directamente.
b) Crean el mismo método y añaden cosas al método, reescribiendo el script predeterminado.

Ambos casos no son muy recomendables, ya que podría provocar errores en los métodos definidos, especialmente el segundo(caso b). Mientras que para el primero(caso a), se trata de un inconvinience en gran medida, sobre todo si se desea distribuir el script, ya que tendrá que señalar que cambios hizo en el script predeterminado, en lugar de copiar y pegar el script escrito en un modulo independiente (Plug and Play ).

En resumen, mediante el uso de alias, podra añadir nuevas funciones sin la necesidad de resscribir la clase completa .

¿Por qué usar alias?
Vamos a empezar con este ejemplo pequeño de script. Usted puede ponerlo en un nuevo juego, o simplemente leer sobre lo que ocurrirá.

Code:

class Scene_Map < Scene_Base

#--------------------------------------------------------------------------

# * Start processing

#--------------------------------------------------------------------------

def start

super

$game_map.refresh

@spriteset = Spriteset_Map.new

@message_window = Window_Message.new

@hud_window = Window_HUD.new

end

Puede ver el "@hud_window = Window_HUD.new" en el metodo "start" en "Scene_Map" Entonces, después de eso, desea utilizar el script de otra persona, que también no utiliza el método alias:

Code:

class Scene_Map < Scene_Base

#--------------------------------------------------------------------------

# * Start processing

#--------------------------------------------------------------------------

def start

super

$game_map.refresh

@spriteset = Spriteset_Map.new

@message_window = Window_Message.new

@time_window = Window_Time.new

end

En este script "@time_window = Window_Time.new" ha sido agregado dentro del "start" del metodo de "Scene_Map"

Si tuviera que poner el segundo script por debajo del primero en el editor de script, el el segundo script se sobrepone al primero y por lo tanto el script "@ hud_window" no es leído por el interpreter.Esto es una mala cosa..

En pocas palabras, con el uso de alias se aumenta la compatibilidad entre los script, por lo que no habrá errores al modificar la misma clase..

¿Cómo?

Agregando códigos a los métodos:

En primer lugar, mira el Scene_Map que viene por defecto, en la línea 27-41:

Code:

#--------------------------------------------------------------------------

# * Termination Processing

#--------------------------------------------------------------------------

def terminate

super

if $scene.is_a?(Scene_Battle)  # If switching to battle screen

@spriteset.dispose_characters   # Hide characters for background creation

end

snapshot_for_background

@spriteset.dispose

@message_window.dispose

if $scene.is_a?(Scene_Battle)  # If switching to battle screen

perform_battle_transition    # Execute pre-battle transition

end

end

Ahora yo quiero añadir esto al código anterior:

Code:

@hud_window.dispose

Sin utilizar el método alias, seria algo como esto:

Code:

#--------------------------------------------------------------------------

# * Termination Processing

#--------------------------------------------------------------------------

def terminate

super

if $scene.is_a?(Scene_Battle)  # If switching to battle screen

@spriteset.dispose_characters   # Hide characters for background creation

end

snapshot_for_background

@spriteset.dispose

@message_window.dispose

if $scene.is_a?(Scene_Battle)  # If switching to battle screen

perform_battle_transition    # Execute pre-battle transition

end

@hud_window.dispose

end

Por lo tanto, volveremos a reescribir el script por defecto y añadiremos innecesarias lineas de código.

Ahora, vamos a tratar de utilizar el método de alias:

Code:

#--------------------------------------------------------------------------

# * Termination Processing

#--------------------------------------------------------------------------

alias puppet_hud_terminate terminate

def terminate

# The usual.

puppet_hud_terminate

# The new code. 

@hud_window.dispose

end

¿Ves? Mediante el uso de método alias, las líneas de código se reducen significativamente.
Ahora tu te preguntas cómo puedo utilizar el método alias ¿verdad?

Pues bien, el formato es el siguiente:

Code:

alias new_name old_name

or

alias_method :new_name, :old_name

Al igual que en el ejemplo anterior:

a) new_name = puppet_hud_terminate
B) old_name = terminate

Sencillo ¿no?

Errores y solucion de problemas:

Al parecer, cuando usas alias en una clase oculta, como mapa de bits, por ejemplo, si presionas "F12" no habrá errores del intérprete.

Al pulsar F12 nuevamente se inicia en Game_Temp de nuevo y se ejecuta a través de todas las clases por lo que se puede decir que comienza de nuevo, pero las clases ocultas no se crean de nuevo cuando llegan a los alias, ya que utiliza el método original en vez del alias que reescribirste, y cuando se llama al método en el juego va a causar un error, para evitar que esto ocurra, te dare una lista de ejemplo que solucionan el problema:

Code:

alias puppet_bank_terminate terminate    # Alias terminate method

alias puppet_bank_update_basic update_basic # Alias update_basic method

alias puppet_bank_update update    # Alias update method

Y cambiarlo por esto:

Code:

if @new_stack.nil?

alias puppet_bank_terminate terminate    # Alias terminate method

alias puppet_bank_update_basic update_basic # Alias update_basic method

alias puppet_bank_update update    # Alias update method

@new_stack = true

end

Esto previene que el error ocurra.

Bueno, esto es todo por ahora.
Agradecimientos:
Trickster.
A mi (puppet04).

RGSS y Ruby - Capitulo 3

2012-04-04T07:55:00.000-07:00

Author: Dubealex
Updated: October 04, 2007
Traductor: Tenshi98

Antes que comenzar, necesitas haber leido el capitulo 1 y 2 para poder seguir con esta clase

Todos los contenidos más importantes que necesitas entender se han explica en el capítulo 1 y 2 de la guia básica de RGSS y Ruby en RMXP. Con el conocimiento adquirido con el capítulo 2 de la lección, deberías ser capaz de abordar el capítulo 3 con más facilidad.

El capítulo 3 abordara la Selectable/Command Window, vamos a aprender a crear y administrar muchos tipos diferentes de menús: menús normales, menú horizontal, menús múltiples columnas, y Múltiples menús (en la misma escena). También vamos a aprender un poco de buena técnica sobre la creación de la CMS, al igual que la forma de gestionar correctamente la ventana en la escena, la forma de asignar una imagen para reemplazar la ventana, cómo utilizar la piel que se desea para cada ventana, etc. Como es habitual, también vamos a cubrir algunos aspectos de la bonificación de una sintaxis en la manera como las vemos. Los bonos información ahora se llamarán "Side-Note".

Por lo tanto, dicho esto, comencemos!

1. Estructura de Selectable/Command Window

Antes de tratar de modificar o crear menús, todos ustedes deben conocer la estructura selectable window y command window en RMXP. Básicamente, la Window Selectable muestra el cursor en los menús, donde es el cursor y la ventana de ayuda, el Window Command muestra los elementos del menú en la ventana que el usuario especifico en su escena.

Vamos a ver cómo un sencillo menú se crea y lo RMXP hizo para crearla. Vamos a ver el menú estándar de la clase Scene_Menu (Esta es el menu principal del juego que aparece al pulsar ESCAPE durante el juego.) Así que abre la página denominada "Scene_Menu".

Code:

class Scene_Menu

#--------------------------------------------------------------------------

# �? オ�-ジェクト�?���-

#     menu_index : コマンド�?�カーソル�?���?置

#--------------------------------------------------------------------------

def initialize(menu_index = 0)

@menu_index = menu_index

end

Este es el método de inicialización de Scene_Menu. En el capítulo 2 no crea ningún método "initialize", sólo hicimos nuestro método "main" ... ¿Por qué hay un método de inicializar aquí? Bueno, este es capaz de especificar el lugar donde queremos que aparezca el cursor en el menú cuando llamamos a ese menú desde otra escena. La posición del cursor en un menú se llama un "Menu Index" en RMXP, por lo que nos referiremos de esta forma a esta nocion. Así pues, si revisas en Scene_Item cerca de la línea # 71, verás una línea que dice: $ scene = Scene_Menu.new (0), este envía un atributo a la clase Scene_Menu, y el índice del menú será de 0, si se cambia el 0 por 1, el cursor aparecerá en el segundo lugar en el menú.

Side Note:
def initialize(menu_index = 0)
En esta línea tenemos una definición de atributo, como se explica en el capítulo anterior, que se define en el paréntesis. Como puede ver nuestro atributo tiene un valor"no modificable" para el de "menu_index = 0". Esto tiene el efecto de decir el atributo "menu_index" es igual a 0 de forma predeterminada, por lo que si llamamos a la clase sin ningún tipo de definición de atributo, que será igual a 0 y no se bloqueará pidiendo atributos. Esto es útil si desea crear el atributo de un método, sino que desea que los valores por defecto para que no se tenga que enviar cada vez que utilice este método en particular.

Code:

def main

# コマンドウィンドウ�'作�?

s1 = $data_system.words.item

s2 = $data_system.words.skill

s3 = $data_system.words.equip

s4 = "Status"

s5 = "Save"

s6 = "Exit"

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])

@command_window.index = @menu_index

Esta es la definición del actual menú. "S" puede estar establecido para "Selección", pero no es importante saberlo, lo que es importante saber es que todas las líneas de S1 a S6 son lo que llamamos "menú", esas son las selecciones de menú que se enumeran en el menú de la ventana. En realidad, lo que se define en las líneas S1 a S6 son la cadena (de texto) que se mostrará en el menú. Recuerde que la S1 a S6 en realidad son variables que se pueden utilizar más adelante, en realidad, se podrían llamar de la forma que desee, e incluso no podía utilizarlos. Las usamos para simplificar la creación de nuestros menús más adelante.

Side Notes:
s1 = $data_system.words.item
En esta línea, recuerda que "$" se refieren a una variable global. data_system se refieren a todos los datos que pueda haber establecido en la base de datos de RMXP. Así que los de la línea S1 de hecho adoptar la palabra que se especifica en la base de datos en el campo de texto "objetos" .

Una vez que toda nuestras opciones del menú se definen, tenemos que crear una ventana para el menú y enviar el atributo necesario de la misma. La siguiente línea se hace cargo de esto:

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])

Si recuerdan en el capítulo 2, aquí basta con crear un objeto denominado "@ command_window", el cual es de la clase Window_Command. Los objetos de Window_Command necesitan 2 atributos para ser creados. Vamos a ver la clase Window_Command para comprobarlo. Abran la clase "Window_Command":

Code:

class Window_Command < Window_Selectable

#--------------------------------------------------------------------------

# �? オ�-ジェクト�?���-

#     width    : ウィンドウ�?�幅

#     commands : コマンド�-�字列�?��?列

#--------------------------------------------------------------------------

def initialize(width, commands)

# コマンド�?�個数�?�らウィンドウ�?�高�?��'算冺

super(0, 0, width, commands.size * 32 + 32)

@item_max = commands.size

@commands = commands

self.contents = Bitmap.new(width - 32, @item_max * 32)

self.contents.font.name = $defaultfonttype  # "All Commands" window font

self.contents.font.size = $defaultfontsize

refresh

self.index = 0

end

Window_Command es una subclase de Window_Selectable, por lo que se tendrá que echar un vistazo a Window_Selectable más adelante. Así, vemos que el métodos initialize necesitan 2 atributos, Ancho y comandos. Por lo tanto la línea de Scene_Menu quedaria:

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])

El primer atributo es de 160, que es el ancho, y la segunda es [S1, S2, S3, S4, S5, S6], que conciste de una matriz que contiene todas nuestras variables S1 a S6 que contienen valores (de texto) para nuestro menú. Bien, ahora Window_Command utiliza un "super" para inicializar el método de su superclase "Window_Selectable":

super(0, 0, width, commands.size * 32 + 32)

Ahora tenemos que abrir "Window_Selectable" y echar un vistazodel método initialize en ese lugar. (Recuerden el capítulo 2, aprendimos de la herencia en aquel entonces.)

Code:

class Window_Selectable < Window_Base

#--------------------------------------------------------------------------

# �? 公�-�インスタンス変数

#--------------------------------------------------------------------------

attr_reader   :index                    # カーソル�?置

attr_reader   :help_window              # ヘルプウィンドウ

#--------------------------------------------------------------------------

# �? オ�-ジェクト�?���-

#     x      : ウィンドウ�?� X 座標

#     y      : ウィンドウ�?� Y 座標

#     width  : ウィンドウ�?�幅

#     height : ウィンドウ�?�高�?�

#--------------------------------------------------------------------------

def initialize(x, y, width, height)

super(x, y, width, height)

@item_max = 1

@column_max = 1

@index = -1

end

Bueno, por supuesto, esta clase también tienen una super clase llamada Window_Base, es normal, window_base contiene toda la base de la creación de una ventana en la pantalla en RMXP. Window_Selectable necesitan cuatro atributos, como son Window_Base la posición x, posición y, anchura y altura de la ventana para crear. Vamos a comprobar la línea súper de nuestra subclase "Window_Command":

super(0, 0, width, commands.size * 32 + 32)

Así, la posición X e Y son en ambos 0, lo que significa que la ventana será a 0:0 de posición sobre la pantalla. (. que es la esquina superior izquierda de la pantalla) la anchura es igual a una variable llamada "ancho", que se envía por Scene_Menu en la línea:

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])

160 es el ancho. La altura se define como "commands.size * 32 + 32", esta parte se pueden haber confundido un poco ... En primer lugar, es necesario recordar que "comandos" es en realidad una variable de matriz se define como:

[s1, s2, s3, s4, s5, s6]

En Ruby se puede utilizar muchas funciones integradas en la "función" con todos las componentes, tales como matrices. Usted puede comprobar todos esos "Funciones" en la siguiente dirección:

http://www.rubycentral.com/book/builtins.html

Si usted consultar la página web, la definición de "tamaño" es la siguiente:

"Devuelve el número de elementos en arr. Puede ser cero."

Por lo tanto, lo que "commands.size" hace es devolver un valor que es igual al número de objetos que figuran en la matriz. En nuestro caso, el tamaño de nuestro arsenal "Comandos" es de 6. Por lo tanto, la línea "commands.size * 32 + 32" ahora puede ser conocido como:

6 * 32 + 32

¿Cuál es el siguiente: 224 ... Nuestra altura es entonces 224. Así que ahora es nuestra ventana al 160X224 0:0 posición en la pantalla. Volvamos a nuestra clase Scene_Menu para ver nuestra última línea, que es:

@command_window.index = @menu_index

Esta línea se establece el atributo "index" a nuestro objeto "@ command_window" igual a nuestra variable de instancia "menu_index", es decir, 0 por defecto ... Pero si otra escena ha enviado un atributo al crear ese menú, utilizará ese valor en lugar, así es como, por ejemplo, que el cursor se vuelve a donde estaba cuando regrese de la opción "Guardar Menú". "@ command_window.index" también se utilizará más adelante en el Scene_Menu para saber donde está el cursor, con el fin de saber qué hacer cuando el usuario pulse "Confirmar" en una selección. (Veremos que en la profundidad más adelante.)

Hay otras cosas para ver, como "Column Max, Row, Cursor Width, etc", todos esos componentes se explicaran por lo que será capaz de crear el tipo de menús que desee. Pero primero, lo que usted necesita es entender como una basica columna trabaja en el menú , y lo que puedes hacer con esta. Una vez que hemos creado este tipo de menús, vamos a crear un menú de varias columnas, y así sucesivamente con el otro tipo de menús.

Ahora que la base de un menú han sido explicadas, podemos hacer nuestro propio menú en nuestra propia escena. Usted ya debe ser capaz de crear su propia ventana, su propia escena y sus propias variables y los objetos, porque ya fueron explicados en el capítulo 1 y 2, así que no vamos a pasar por todo eso otra vez.

2. Creación de un menú horizontal simple

En primer lugar, necesitamos una escena sencilla para crear nuestro menú pulg He creado un menú de diseño simple y ventana que se puede copiar y pegar, vamos a usar ese diseño de nuestro menú. Este diseño conciste de tres ventanas, una para visualizar el menú, otro para mostrar la ventana de ayuda, y otra para mostrar el contenido de una selección en el menú. Esto se verá así: (Cuando está vacío ...)

Basta con crear una nueva página en el editor de script, y pegar todo el código siguiente dentro de él: (Usted puede llamar a esta página "menú horizontal simple".

Code:

#===================================================

# �-?  RGSS & Ruby Lesson -- Chapter 3 [SIMPLE HORIZONTAL MENU]

#===================================================

# By: Dubealex

# www.dubealex.com (Creation Asylum)

#

# Last Update: April 14, 2005

#===================================================

#===================================================

# �-� CLASS Scene_Chapter3_menu1 BEGINS (Simple Horizontal Menu)

#===================================================

class Scene_Chapter3_menu1

def initialize(menu_index = 0)

@menu_index = menu_index #Store the cursor position

end  

#--------------------------------------------------------------------------------------------------------

def main

@window_a1=Window_a1.new #Content Window

@window_a1.update(false) #Decide whether to show/hide the content...

@window_a1.x=200

@window_a1.y=100

@window_a3=Window_a3.new #Help Window 

@window_a3.update(" ") #Send the help text by default to the Help Window...

#This is what makes the scene update itself constantly:

Graphics.transition

loop do

Graphics.update

Input.update

update #Call the method DEF UPDATE starting below

if $scene != self

break

end

end 

#Execute when exiting the scene:

Graphics.freeze

@window_a1.dispose

@window_a2.dispose

@window_a3.dispose

end

#--------------------------------------------------------------------------------------------------------

def update

@window_a2.update #menu

if Input.trigger?(Input::B) #Press ESCAPE to exit

$game_system.se_play($data_system.cancel_se)

$scene = Scene_Map.new

$game_map.autoplay #Because we play music in the menu...

end 

end

#--------------------------------------------------------------------------------------------------------

#Options Method Start Here:

#--------------------------------------------------------------------------------------------------------

end #of the Scene !

#===================================================

# �-� CLASS Scene_Chapter3_menu1 ENDS (Simple Horizontal Menu)

#===================================================

#===================================================

# �-� CLASS Window_a1 BEGINS (Content Window)

#===================================================

class Window_a1 < Window_Base

def initialize 

super(0, 0, 440,380)

self.contents = Bitmap.new(width-32, height-32)

self.contents.font.name = "Tahoma"  

self.contents.font.size = 20

end

def update(content) #Receive the argument from the menu

if content == false #If false, don't show content

self.contents.clear 

self.contents.draw_text(0, 0, 120, 32, "No Content...")

else #else, if true, show it...

self.contents.clear 

self.contents.draw_text(0, 0, 440, 32, "SHOW CONTENT")   

end

end

end 

#===================================================

# �-� CLASS Window_a1 ENDS (Content Window)

#===================================================

#===================================================

# �-� CLASS Window_a3 BEGINS (Help Window)

#===================================================

class Window_a3 < Window_Base  

def initialize 

super(0, 0, 640,100)

self.contents = Bitmap.new(width-32, height-32)

self.contents.font.name = "Tahoma"  

self.contents.font.size = 20

end

def update(help_text) #Receive argument, show relevant help text in window

self.contents.clear #Clear the content before displaying new data !

self.contents.draw_text(0, 0, 440, 32, help_text) #show the content of "help_text" variable

end

end 

#===================================================

# �-� CLASS Window_a3 ENDS (Help Window)

#===================================================

Este código no funcionará hasta que se agregue al script del menú, ya que la ventana no se ha definido aún dentro del propio menú. Así que sigue leyendo, y prueba tratando de insertar el script dentro del menu.

Ahora hay que añadir las cosas que queremos en esa escena. Primero lo primero, vamos a diseñar el menú y lo que hará. Así que aquí va:

Opción 1: ITEMS -> se abrirá Scene_Items.
Opción 2: INFOS -> Mostrará un texto en la ventana de contenido.
Opción 3: MUSIC A -> se puede reproducir música de fondo A.
Opción 4: MUSIC B -> se puede reproducir música de fondo B.
Opción 5: EXIT -> saldrá como ESCAPE.

Ahora que sabemos lo que vamos a hacer, podemos seguir adelante y crear la estructura básica para el menú de la derecha , y pulir cada función (método) para las opciones más adelante. En primer lugar, vamos a añadirlas en el diseño del "menú horizontal simple" en nuestro método de la escena principal.

Así que abrir la página que ha creado anteriormente "menú horizontal simple" y vaya a la línea # 30. Vamos a añadir nuestro menú de allí, pegue el siguiente código en la línea # 30:

Code:

s1 = "Items"

  s2 = "Infos"

  s3 = "Music A"

  s4 = "Music B"

  s5 = "Exit"

  @window_a2 = Window_Command.new(200, [s1,s2,s3,s4,s5]) #Remember, 200 is the Width

  @window_a2.y=100 #Set a position for the menu other than 0:0

  @window_a2.height=380 #Force a new height for the menu window

  @window_a2.index = @menu_index

Para empezar, ahora que la escena va a funcionar, crear un evento en el mapa y añadir el siguiente llamar script:

Code:

$scene=Scene_Chapter3_menu1.new

Si vas a hablar con el evento, este te mostrara la escena, pero el menú no hara nada, mas que pulsar ESCAPE para salir de la escena y volver al mapa.

Ahora vamos a añadir la visualización del texto de ayuda para el menú. El texto que se mostrará en la ventana de ayuda (@ window_a3) se cambiará dependiendo de la posición del cursor en el menú. Para permitir esto, tenemos que saber siempre donde está el cursor en el menú .... Así que tenemos que agregar el código en la actualización de la definición de nuestra escena, ya que este es el método que está siendo constantemente "llamada" mientras estamos en nuestra escena.

Así que en la definición de actualización (todavía en la Scene Class!), Y justo debajo de @window_a2.update agregue este código:

Code:

#THIS IS FOR THE HELP DISPLAY WINDOW:

case @window_a2.index #window_a2 is the menu... index is it's cursor position !

  when 0 #Remember that the cursor position start at 0, because it's an Array !!

    @window_a3.update("Open the item selection window") #item - s1

  when 1

    @window_a3.update("Display some info in the content window") #infos -s2

  when 2

    @window_a3.update("Play BGM A") #Music A - s3

  when 3

    @window_a3.update("Play BGM B") #Music B - s4

  when 4

    @window_a3.update("Exit the menu and return to the map") #Exit - s5

end

Ahora, si pruebas una vez más, verás que al mover el cursor de opción en opción, la ventana de ayuda en la parte superior se mostrará la información sobre herramientas relevantes para la opción seleccionada. ¿Cómo se hace? Bueno, si no lo ha adivinado por mirar el código, siga leyendo:

Nuestra ventana de ayuda se denomina Window_a3 ... aquí está el código para ello:

Code:

class Window_a3 < Window_Base

2

def initialize

 super(0, 0, 640,100)

 self.contents = Bitmap.new(width-32, height-32)

 self.contents.font.name = "Tahoma"

 self.contents.font.size = 20

end

9

def update(help_text) #Receive argument, show relevant help text in window

 self.contents.clear #Clear the content before displaying new data !

 self.contents.draw_text(0, 0, 440, 32, help_text) #show the content of "help_text"

variable

end

14

end

Línea n º 1 a 9 no debería ser un problema, si usted no los entiende, trate de leer el capítulo 1 y 2, que trata de ellos. La línea 10 crea un nuevo método llamado "update" que se puede llamar desde nuestro menú (de nuestra escena) para actualizar lo que está escrito en la parte superior(help_text). Estamos pidiendo un argumento que hemos llamado "help_text", y nos muestra que el argumento en la pantalla en la línea # 12 ...

Si nos fijamos en nuestro código en el menú, podemos ver que cada línea cambia el texto que aparece en la ventana de ayuda:

@window_a3.update("New Text")

@ window_a3 es nuestro objeto que hemos creado en la definición principal de nuestra escena, y la actualización es el método que hemos creado en nuestra clase Window_a3 (explicado anteriormente). Lo que sigue es el argumento (el texto de ayuda para mostrar) que se envía a ese método de actualización.

Todos estamos de acuerdo que un menú sin ningún tipo de función no es en realidad un menú completo ... Así que ahora es el momento de añadir las funciones. No es tan complicado, necesitamos un método para cada opción que tenemos en el menú, en este caso, tenemos 5 opciones, por lo que tendrá que crear cinco métodos. Así que vamos a añadirlos en este momento:

Recuerda el lugar donde se añadiste el código de la pantalla de ayuda antes, en definición de actualización (below@window_a2.update)? Pues bien, el método que tendrás que agregar en la escena va justo despues del "def update" Sólo tienes que buscar las siguientes observaciones para encontrar exactamente donde:

Code:

#Options Method Start Here:

Ahora, debajo de esa línea, pega este código, te lo explicaré después.

Code:

def item #s1, menu_index=0

  $game_system.se_play($data_system.decision_se) #play an SE

  $scene = Scene_Item.new #Syntax to change scene

end  

def infos #s2, menu_index=1

@window_a1.update(true)

end  

def music_a #s3, menu_index=2

  Audio.bgm_play("Audio/BGM/song_a.mid", 100, 100) #Play custom BGM

end 

def music_b #s4, menu_index=3

  Audio.bgm_play("Audio/BGM/song_b.mid", 100, 100) #Play custom BGM

end 

def exit #s5, menu_index=4

  $game_system.se_play($data_system.cancel_se) #play an SE

  $scene = Scene_Map.new #Syntax to change scene

  $game_map.autoplay #Because we play music in the menu...

end

Side Note:
Utilizando el método de las opciones del menú

Tu no necesitas (no es necesario) para usar el método para cada menú de opciones, especialmente si son sencillos y cortos como este ejemplo de menú. Pero me decidí a mostrar de esa manera porque a veces, la opción de menú podría tener un funcionamiento mas larga y complicada, y en este caso, es mejor para ellos se descomponen en un método diferente. Si quieres probarlo sin necesidad de utilizar el método, sólo tiene que reemplazar cada llamada al método desde dentro de la "Declaración de Caso" por el contenido de cada método, y voilà? . Yo prefiero usar el método, de esa manera es mejor clasificados.

Una pequeña nota, las líneas que comienzan con Audio.bgm_play tiene que estar configurado con los nombres de sus propios archivos de audio, presentes en Audio \ BGM.si quiere otro archivo, cambie el nombre que esta entre parentesis.

No hay mucho que explicar, ya que estas son operaciones muy simples. No creo que tengo que explicar el propio código. Cada uno de los métodos serán llamados por un nuevo código que vamos a añadir en la actualización de la definición, justo debajo del código que añadido a la ventana de la pantalla de ayuda. Por lo tanto, busque este código en "Def update" de nuestra escena:

Code:

@window_a3.update("Exit the menu and return to the map") #Exit - s5

end

Y a continuación, agregue el siguiente código:

Code:

#THIS IS FOR THE OPTION FUNCTIONS:

if Input.trigger?(Input::C) #Do the following if ENTER is pressed...

case @window_a2.index #window_a2 is the menu... index is it's cursor position !

  when 0 #Remember that the cursor position start at 0, because it's an Array !!

    item #item - s1

  when 1

    infos #infos -s2

  when 2

    music_a #Music A - s3

  when 3

    music_b #Music B - s4

  when 4

    exit #Exit - s5

  end  

end

Ahora si pruebas el menu, veras que este se actualiza con las opciones antes indicadas, por lo tanto, si deseas mostrar otra cosa en lugar de texto, puedes modificar el codigo a tu gusto, el cual, es el objetivo de este tutorial despues de todo.

Yo no tengo el tiempo para seguir haciendo tutorial en el momento ..

Esto fue lo ultimo que puso Dubealex, al parecer no continuo con el tutorial, ya que no he encontrado la parte 4, asumo que tendre que continuar yo la parte 4...