Creado por: Necrozard

Está totalmente prohibido distribuir esta obra sin reconocer al autor.

Una obra licenciada bajo Creative Commons (CC)

INDICE

LECCION 1: INTRODUCCION ----------------------------------------- Pag. 4- ¿Que es Ruby?- ¿Que es la Programación Orientada a Objetos?- ¿Que es RGSS2?- Colores del Editor

LECCION 2: VARIABLES Y CONSTANTES ------------------------- Pag. 6- ¿Que es una variable?- ¿Que es una constante?- Números aleatorios- Operadores matemáticos

LECCION 3: ARRAYS & HASHES ------------------------------------- Pag. 8- ¿Que es un Array?- ¿Que es una tabla Hash?

LECCION 4: CONDICIONALES Y BUCLES ----------------------- Pag. 10- Condicional IF- Condicional CASE- Condicional UNLESS- Operadores lógicos- Bucle for- Bucle Loop do/Break- Bucle While

LECCION 5: LOS METODOS ------------------------------------------ Pag. 15- ¿Que es un método?- Parámetros- ¿Como inicio un método dentro de la misma clase?

LECCION 6: LAS CLASES --------------------------------------------- Pag. 18- ¿Que es una clase?- ¿Como se forma una clase?- ¿A que se le llama Herencia de una clase?- Alias

- Accesos a variables

LECCION 7: EL PODER DE RGSS2 ---------------------------------- Pag. 21- Comenzando con RGSS2- Gráficos- Comandos más utilizados

LECCION 8: LAS VENTANAS ---------------------------------------- Pag. 23- ¿Que son las ventanas en RGSS2?- ¿Como creo una ventana?- ¿Como llamo a una ventana?- Window_Base

LECCION 9: LAS ESCENAS ------------------------------------------- Pag. 27- ¿Que es una escena?- ¿Como llamo a una escena?- ¿Como creo una escena?- Resumen general de la Scene

LECCION 10: FINAL DE LA GUIA ------------------------------------Pag. 31- Despedida y contacto

Lección I: Introducción

– ¿Qué es Ruby?

Ruby es un lenguaje multiplataforma, interpretado y orientado a objetos. Fue creado por Yukihiro Matsumoto en 1993, como un lenguaje “facilitador de trabajo”, que divirtiera al programador a la hora de hacer su trabajo.

Ruby es:

• Poderoso: Ruby combina el poder de la pura orientación de objetos de Smallwalk, con la conveniencia de un lenguaje como Perl. Los programas de Ruby son compactos, fáciles de leer, y muy eficaces a la hora de mantener.

• Simple: La sintaxis del lenguaje es muy simple, no existe ningún caso especial que debas recordar. Instancias, enteros, clases, son todos objetos, como todo lo demás. Una vez que tengas lo básico, es fácil pensar cosas nuevas, y pensarlas bien.

• Habilitado: Ruby es un lenguaje de código libre, y está totalmente habilitado de uso para la creación de programas.

– ¿Qué es la Programación Orientada a Objetos?

Es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, modularidad, polimorfismo y encapsulamiento. Su uso de popularizó a principios de la década de 1990. Actualmente son muchos los lenguajes de programación que soportan la orientación de objetos, uno de ellos, Ruby.

– ¿Qué es RGSS2?

RGSS2 (Ruby Game Scripting System) usa Ruby como su lenguaje base, por ello, si sabes Ruby, también sabes RGSS. La diferencia entre Ruby y RGSS2, que es muy importante para saber es que RGSS2 es un lenguaje que usa componentes ya creados.En Ruby solo, si quieres cargar un gráfico y mostrarlo por pantalla, no podrás hacerlo como en RGSS2, debes escribir todo el código desde un principio.Todos los comandos gráficos, los contiene RGSS2.

– Colores del Editor

Siempre es útil aprenderse los colores del editor de Ruby. Pasaré a explicarlos:

• Azul: Representa las palabras reservadas de la sintaxis.Ejemplos: def, class, if, break

• Marrón-rojizo: Representa los números en el código.Ejemplos: 1, 20, 35, 120

• Celeste: Representa los operadores.Ejemplos: =, *, +, /

• Verde: Representa los comentarios. Éstos son ignorados por Ruby. Solo sirven de guía al programador.Ejemplos: # Comentario, =begin Comentario de muchas líneas =end

• Violeta: Representa una cadena de texto (String)Ejemplos: “Hola Mundo”, “Enseñando Ruby”

Hemos ya llegado al final de la primer lección, vamos avanzando bien.Ya tienes una idea de lo que es Ruby y RGSS2, sus diferencias, características, y algo también importante, los colores del editor.

Lección II: Variables y Constantes

– ¿Qué es una variable?

En programación, las variables son estructuras de datos que, como su nombre indica, pueden cambiar el contenido a lo largo de la ejecución de un programa.Una variable corresponde a un área reservada en la memoria principal del computador.

Tipos de variables en Ruby:

• Globales: Una variable global en Ruby (y en la totalidad de los lenguajes de programación), significa que tiene un alcance total en el programa. Una variable global puede ser modificada desde cualquier parte del programa.Las variables globales se diferencian de las demás porque comienzan con el símbolo del dólar ($) antes del nombre original.Ejemplos: $game_system, $game_party, $variable_global

• De clase: Las variables de clase en Ruby, significa que tiene un alcance solo dentro de la clase donde fue asignada. Una variable de clase puede ser modificada dentro de cualquier metodo de la misma clase, pero no desde otra clase.Se diferencian porque comienzan con el símbolo arroba (@) antes del nombre original.Ejemplos: @window_gold, @actor, @variable_de_clase

• Locales/De método: Las variables locales o de método, en Ruby (y en la totalidad de los lenguajes de programación), significa que tiene un alcance solo dentro del método en que fue asignada. No puedes acceder a ella ni por diferentes métodos ni por diferentes clases, solo dentro de su método.Se usa sobre todo para contadores y variables que sabemos que nunca las vamos a usar fuera de ese método.Se diferencian porque NO comienzan con ningún símbolo, como si fuera una palabra normal.Ejemplos: contador, var_local

– ¿Qué es una constante?

Una constante es lo mismo que una variable, con la importante diferencia de que su valor no puede variar a lo largo de la ejecución del programa. O sea, que no se puede modificar después de dado el valor en el script.Se diferencian de las variables porque se escriben enteramente en Mayúsculas.

Ejemplos: MAX_MEMBERS, CONST

Alcance de las constantes según donde se asignen:

• Dentro de una clase o módulo: Una constante asignada dentro de una clase o módulo, solo se puede utilizar/saber su valor, dentro de esa clase o módulo.Advertencia: Cuidado, estamos hablando de módulos, no de métodos, son cosas diferentes que explicaré a lo largo de la Guía.

• Fuera de la clase o módulo: Una constante asignada fuera de una clase o módulo, se usan mediante el operador :: seguida de una palabra que indique el módulo o clase apropiados.

Puede que esto de los alcances de las variables y constantes te parezca un poco difícil de entender a lo primero, no te preocupes, es común, sigue leyendo y verás como se facilita con el tiempo.

– Números aleatorios

Puedes asignar a una variable o constante un número aleatorio. Se hace de la siguiente manera:

Código Ruby

@numero_aleatorio = rand(num)

Código Ruby

El rango del número aleatorio será desde el 0 hasta el valor indicado dentro de las variables. 0 <= x <= num.

Para obtener un número aleatorio de por ejemplo -200 y 200, se debe hacer de la siguiente manera:

Código Ruby

@numero_aleatorio = rand(400) - 200

Código Ruby

– Operadores matemáticos

Los operadores matemáticos son los símbolos que usamos en matemática para sumar, restar, y más, algunos son diferentes, pero cumplen la misma función.

• +: Igual que en matemática, puedes sumar valores, variables, constantes, etc.• -: También, exactamente igual que en matemática, sirve para restar valores.• /: Signo de división, en todos los lenguajes de programación es igual.• *: Signo de multiplicación.• **: Potencia en matemática.• %: Signo de módulo. Indica el resto de un valor y otro.

Lección III: Arrays & Hashes

– ¿Qué es un Array?

Array, también llamado lista o arreglo, es un conjunto ordenado de variables que se pueden leer/escribir.La ventaja de usar arrays es que puedes tener la cantidad de variables que quieras en un solo conjunto, si no entiendes todavía no te preocupes, pasemos a explicarlo más claramente.

Código Ruby

@nombres = [“Luis”,”Alberto”,”Jose”]

print @nombres[0]print @nombres[1]print @nombres[2]

@nombres[0] = “Nombre_Cambiado”

Código Ruby

@nombres = [“Luis”,”Alberto”,”Jose”]: Asignamos a un array, en este caso @nombres, 3 valores, los tres de tipo texto (String). Dejar claro que un array puede contener todo tipo de datos, y es más, puede existir un array con una mezcla de los mismos.

print @nombres[0]: La función print, lo que hace es imprimir un texto por pantalla, por lo que le estamos diciendo al computador que imprima por pantalla el valor @nombres[0].Lo que está entre corchetes indica la posición del dato dentro del array, recordar que en los lenguajes de programación, se comienza a contar desde 0 y no desde 1.Por lo tanto @nombres[0] indica el valor del primer dato en el array, o sea “Luis”. Pasa igual con las siguientes lineas, imprimen el valor de cierto dato dentro del array.

@nombres[0] = “Nombre_Cambiado”: A simple vista nos damos cuenta de lo que hace esta linea, es tan fácil como decir que le está asignando un valor nuevo al dato en la posición 0 del array, o sea sustituyó “Luis” por “Nombre_Cambiado”, y el array quedaría así al final: @nombres = [“Nombre_Cambiado”,”Alberto”,”Jose”]

– ¿Qué es una tabla Hash?

Los Hashes, también conocidos como Arrays asociativos, mapas o diccionarios.La diferencia entre array y hash, es que, como bien vimos anteriormente, el valor de un dato del array esta en cierta posición, y ese dato tiene como referencia el valor de la posición, a diferencia de los Hashes, estos tienen la característica de tener como referencia cualquier tipo de valor, pasemos a explicarlo mejor:

Código Ruby

@nombres = {“Luis” =>”Primo”,”Alberto”=>”Hermano”,”Jose”=>”Padre”}

print @nombres[“Luis”]

Código Ruby

@nombres = [“Luis” =>”Primo”,”Alberto”=>”Hermano”,”Jose”=>”Padre”]: Prácticamente igual que el array, nada mas que le asignamos un valor distinto al índice de posición.Fijate también, y ten mucho cuidado cuando vayas a asignar una, que los valores no van entre corchetes, sino que van entre llaves {}.

print @nombres[“Luis”]: Está claro lo que hace, imprime por pantalla el valor asignado al dato “Luis” dentro del Hash, o sea que devolverá “Primo”.

Lección IV: Condicionales y Bucles

– Condicional if

El Condicional if es uno de los mas usados en RGSS2, para verificar datos, y más.Lo que hace este condicional es verificar si la expresión dada es verdadera, si se valida, ejecutará una serie de instrucciones que tendrás que dar después de la expresión. También está la posibilidad de indicar ciertas instrucciones si la expresión es falsa, con else. Pasemos a explicar:

Código Ruby

@num1 = 5@num2 = 10

if @num1 == @num2print “Ambos números son iguales”

elseprint “Los números son diferentes”

end

Código Ruby

@num1 = 5: Aquí lo único que hicimos fue asignarle un valor a una variable de clase. Ésta es una gran característica de Ruby, ya que cuando asignas un valor a la variable, ya directamente la estas declarando, no tienes que hacer ninguna declaración anterior, solo asignarle el valor y listo, ya estará declarada.

if @num1 == @num2: Bueno, aquí llegamos a la primera línea del condicional IF. Como puedes observar, todo condicional if, comienza con la palabra reservada if, seguido de la expresión que quieras verificar su valides. En este caso expresamos que si la variable @num1 es IGUAL (==) a @num2, y está claramente que es falso, declaramos a @num1 con un valor de 5 y a @num2 con un valor de 10, son diferentes valores. Por lo que es falsa y la siguiente linea no se ejecutará.

print “Ambos números son iguales”: El comando print imprime por pantalla una cadena de texto que se le indica después. En este caso, diríamos que Ambos números son iguales, pero eso solo si la condición es verdadera, pero no fue verdadera, ya que 5 no es igual que 10, por lo que esa linea no se ejecutará y pasará directamente al end y se terminará el condicional.

else: Esta palabra lo que hace es hacer una excepción al condicional if, para que ejecute ciertas instrucciones si la expresión es falsa.

print “Los números son diferentes”: Esto es lo que ejecutará el condicional, ya que la expresión, fue falsa.

end: Palabra muy importante, todo condicional, método, clase, y más, deben terminar si o si con un end, sino no se marca el final y es muy probable que te de errores.

– Condicional case

Este condicional toma el valor de una variable cualquiera, y ejecuta diferentes instrucciones según el caso que sea verdadero. Vamos a mirar un ejemplo existente en RPG Maker VX, una parte del método update de Scene_Title, donde se expresa un case, vamos a ello:

Código Ruby

case @command_window.index when 0 command_new_game when 1 command_continue when 2 command_shutdownend

Código Ruby

case @command_window.index: Primera línea del condicional case, allí es donde indicas que variable quieres verificar, o sea en que variable quieres que se verifiquen los valores.En este caso en una variable de clase llamada @command_window.index, lo que indica es la posición dentro de la caja de comandos del Scene_Title.

when 0: When significa en inglés “Cuando”, por lo tanto Cuando el valor de @command_window.index es 0, se ejecuten las siguientes instrucciones.

command_new_game: Esta es la instrucción seguida del when 0, por lo tanto esta solo se ejecutará si y solo si @command_window.index vale 0, Si te preguntas que es esta línea, pues es una llamada a otro método dentro de la misma clase, pasaré a explicarlo en las próximas lecciones.Como ves, las siguientes lineas son iguales a las explicadas, pero verificando diferentes valores para ejecutar diferentes instrucciones.Dejar claro que los when no terminan con ningún end, pero el cada case siempre debe terminar con uno.

– Condicional unless

Vamos a explicar el último condicional de ésta lección. El condicional unless es lo contrario al if, se ejecutarán las instrucciones si y solo si la expresión es falsa. Vamos a un ejemplo para explicarlo mejor:

Código Ruby

@nombre = “Pepe”

unless @nombre == “Santiago”print “¡Si no te llamas Santiago, no entras!”

end

Código Ruby

@nombre = “Pepe”: Asignamos a @nombre, la cadena de texto “Pepe”.

unless @nombre == “Santiago”: La palabra unless significa “A menos que”, lo por lo tanto, traducido sería “A menos que” la variable @nombre sea igual a “Santiago” no se ejecuten las instrucciones. Entonces, si el valor de la variable @nombre no es “Santiago”, se ejecutará el bloque. Totalmente lo contrario al IF, si la expresión que le damos después del unless es falsa, se ejecuta el bloque de instrucciones.

print “¡Si no te llamas Santiago, no entras!”: Por lo tanto, si @nombre es igual a “Santiago”, es falso, se imprimirá por pantalla “¡Si no te llamas Santiago, no entras!”. Fácil, ¿verdad?.

end: Por supuesto, como todo condicional, lo terminamos con un end.

– Bucle for

El bucle for sirve para repetir una cantidad limitada de veces ciertas instrucciones, dependiendo del valor de una variable. Vamos al ejemplo:

Código Ruby

for i in 0..10print i

end

Código Ruby

for i in 0..10: El bucle debe comenzar por la palabra reservada for, seguida de la variable, la palabra reservada in, y el rango de contador. Hay una pequeña diferencia entre 0..10 (dos puntos) y 0...10 (tres puntos), el primero toma un rango desde el primer número hasta el último, o sea un rango total, del 0 al 10, y el segundo (tres puntos), toma un rango desde el primer numero hasta el penúltimo, del 0 al 9.

end: Como todo condicional y bucle, marca el final del mismo.

Ésto imprimirá por pantalla 10 veces la variable i, y como i es el contador, imprimirá 1,2,3,4... hasta llegar al 10.

– Bucle loop do/break

Éste bucle sirve para repetir continuamente ciertas instrucciones hasta que se lo rompa/pare, con la palabra break. Veamos un ejemplo mas complejo:

Código Ruby

loop do Graphics.update Input.update update if $scene != self

break endend

Código Ruby

Comenzaré a explicarlo.Todo bucle Loop do, obviamente comienza con las palabras reservadas loop do, a pesar de que loop no se pone con color azul, no le des importancia, es así. Dentro del loop do, van las instrucciones que quieras que se repitan una y otra vez (casi siempre son por updates), y el end final.Pasare a explicar la linea desconocida dentro del bucle:

Código Ruby if $scene != self

break end

Código Ruby

Comienza con un condicional if, ya lo habíamos visto antes, seguido de la variable global $scene.

$scene, significa la Escena Actual del juego, El Titulo es una escena, el menú también, el mapa también es un escena.

self, significa YO, PROPIO, MIS.

Por lo tanto, esas instrucciones dicen que si la escena actual ($scene) no es (!=) YO (self), o sea que si la escena actual no es la clase en que está ese loop, ejecuta el comando break, en ciertos términos, rompe/termina el bucle, para después terminar la clase.

– Bucle while

Éste bucle sirve para repetir continuamente ciertas instrucciones, pero a diferencia de loop do, este termina cuando la expresión dada sea falsa. Vamos a un ejemplo:

Código Ruby

@num = 10

while @num == 10print “@num sigue siendo igual a 10”

end

Código Ruby

Todo bucle while, comienza con la palabra reservada while, seguido de la expresión a verificar. En este caso verificamos si @num==10. While significa “Mientras”, por lo tanto mientras @num sea igual a 10, que las instrucciones se ejecuten. O sea, si @num vale 10 en todo el programa, será un bucle infinito, ya que si no cambia de valor, seguirá ejecutando sus instrucciones.

– Operadores lógicos

Los operadores lógicos indican el formato de validar cierta expresión en un condicional o bucle. Por ejemplo este que vimos anteriormente:

Código Ruby

@num = 10

while @num == 10print “@num sigue siendo igual a 10”

end

Código Ruby

El operador lógico en este caso es ==, el signo de igual.Hay una importante diferencia entre = y ==, el primero es ASIGNAR, con él puedes asignarle un valor a una variable, constante, etc. El otro es IGUAL, para comparar valores en condicionales o bucles. Pasemos a la lista de los mismos:

• Igual: El símbolo de igual para la comparación en condicionales y bucle es: ==Sirve para verificar si un valor es igual a otro.

• Or: Significa ó en matemática. O sea puedes comparar dos valores verificando si uno o el otro es verdadero. El símbolo es: || ó or

• Not: Significa No es cierto, negación. Por lo tanto es para verificar que algo no es cierto, el símbolo es: != ó !(expresión)

• Mayor: El símbolo mayor, para verificar si un dato es mayor que otro, excluyéndose. Se expresa con el símbolo: >

• Mayor o igual: Es lo mismo que mayor, pero incluyendo el valor dado. Símbolo: >=• Menor: El símbolo menor para verificar si un dato es menor que otro, excluyéndose. Se expresa

con el símbolo: <• Menor o igual: Es lo mismo que menor, pero incluyendo el valor dado. Se expresa de la

siguiente manera: <=

Lección V: Los métodos

– ¿Qué es un método?

Un método es un objeto, todo lo que se manipula en Ruby es un objeto, el resultado de las operaciones también son objetos.La única forma que tenemos de manipular un objeto, es con un método.Todo metodo necesita un objeto, es fácil ver que objeto recibe el método, es la palabra a la izquierda del punto.Vamos a ver un pequeño ejemplo y explicarlo paso a paso:

Código Ruby

def ladraprint “Guau - Guau”

end

Código Ruby

Pasemos a explicar línea por línea ese método:

• def ladra: Todo método debe comenzar si o si con la palabra reservada def, seguido del nombre del método.

• print “Guau – Guau”: Imprime por pantalla “Guau – Guau”.

• end: Todo método, como comienza, termina, por lo tanto, al final se pone end para comunicar a la computadora que ese las instrucciones de ese método, terminaron allí.

Supongamos que ese método está dentro de una clase llamada Perro (pasaré a explicar esto de las clases en la siguiente lección). Para ejecutar/llamar a ese método desde otra clase, tendremos que indicar de quien proviene, o sea, el ladrido no viene de cualquier lado, no viene de una vaca, ni del ruido de la lluvia, viene del perro, por lo tanto, por lógica, su clase podría llamarse Perro, y lo ejecutaríamos de la siguiente manera:

Código Ruby

Perro.ladra

Código Ruby

Esta expresión devolverá por pantalla “Guau – Guau”, no porque Ruby es inteligente y se da cuenta de que un perro ladra, sino porque lo indicaste en el método al que estas llamando.

– Parámetros

Los parámetros son valores que se pueden pasar al método desde otro método o clase diferente. Ese dato puede ser importante para el método receptor, ya que puede actuar según el valor de ese dato, pasemos a explicarlo mas claramente, con un ejemplo:

Código Ruby

def ladra(numero_de_veces)print “Guau – Guau” * numero_de_veces

end

Código Ruby

Pasemos a explicarlo:

• def ladra(numero_de_veces): Como dijimos, todo método debe comenzar si o si con la palabra reservada def, seguido del nombre del método. Lo que está entre paréntesis, es el parámetro, claramente se pueden pasar mas de 1 parámetro a un método, pero este no es el caso. La palabra que esta entre los paréntesis es el nombre de la variable local (o sea que solo se puede modificar dentro de ese método), la cuál tiene guardado en si, el dato pasado desde otro método o clase.Si queremos que ese dato no se pierda, para poderlo usar en una clase completa, lo asignamos a una variable de clase:

Código Ruby@numero_de_veces = numero_de_vecesCódigo Ruby

• print “Guau – Guau” * numero_de_veces: Aquí se imprime por pantalla “Guau – Guau” el numero de veces que se le indique por el parámetro. El símbolo * significa multiplicación.

• end: Le indicamos al computador que el método termina allí.

Fácil, ¿verdad?. De a poco se va entendiendo cada vez mejor, y sobre todo, se pone mas divertido, créeme.

– ¿Como inicio un método dentro de la misma clase?

Si creas un método dentro de una clase, no se ejecutará hasta que lo inicies, puede estar creado, pero no ejecutándose, por lo tanto para iniciarlo dentro de la misma clase, es tan fácil como escribir el nombre del método:

Código Rubynombre_del_metodoCódigo Ruby

Si escribes el nombre del método, éste comenzará a ejecutar sus instrucciones.

Como ves, los métodos no son nada del otro mundo, son como procesos paralelos entre ellos. Ahora paso a explicar en la siguiente lección, las clases, una de las cosas más importante de Ruby.

Lección VI: Las clases

– ¿Qué es una clase?

Una clase es también un objeto, y se usa para crear “sub-objetos”, imaginen la clase llamada Scene_Title, esta clase a su vez llama a Window_Command, para el comando de elecciones, y posteriormente llama a Scene_Map.

– ¿Como se forma una clase?

Para formar una clase, debes seguir ciertas normas, como todo lo demás. Vamos al ejemplo:

Código Ruby

class nombreend

Código Ruby

Esta clase obviamente no hace nada, porque no contiene instrucciones.

Como puedes ver, toda clase comienza con la palabra reservada class, seguido del nombre de la clase, después le siguen los métodos, y finalmente el end que marca el final de la clase.

– ¿A que se le llama Herencia de una clase?

La herencia, como bien lo explica la palabra, tiene la característica de heredar los métodos de otras clases. Por ejemplo Window_Gold, tiene como herencia a Window_Base, porque hereda sus métodos, para poder crear una ventana funcional. Para heredar una clase de otra, simplemente escribimos lo siguiente:

Código Ruby

class nombre < nombre_de_clase_a_heredar

Código Ruby

Como ves, simplemente se pone el símbolo de menor (<) después de la clase heredada y antes de la clase a heredar.

– Alias

El Alias lo que hace exactamente es sumarle a cierto método, ciertas instrucciones, veamos un ejemplo:

Código Ruby

class Window_Sample < Window_Base

alias sample_alias_update updatedef updatesample_alias_update@window.updateend

end

Código Ruby

Si te da una impresión de dificultad, no te alteres, ve mirando línea por línea y verás que lo hemos dicho todo.El Alias, se forma primeramente con la palabra reservada alias, seguida del “alias” o sea, sobrenombre, del método, un espacio, y allí el nombre original del método.En este caso le di como “alias”, sample_alias_update, esta claro que el alias debe ser distinto al original, si no, no tendría sentido.A continuación creamos nuevamente el método con el nombre original, y dentro de él, no lo olvides, llamar al alias, en este caso, sample_alias_update, sino es probable que te mande un error.

Lo que hace el alias es agregar otra instrucción después de las instrucciones originales, entonces, sino usas el alias en un método, reemplazarías todo.

– Accesos a variables

Existen ciertos comandos para acceder a las variables de las clases. Veamos un ejemplo en el Game_Party:

Código Ruby

class Game_Party < Game_Unit

MAX_MEMBERS = 4

attr_reader :gold attr_reader :steps attr_accessor :last_item_id attr_accessor :last_actor_index attr_accessor :last_target_index

def initialize super @gold = 0 @steps = 0 @last_item_id = 0 @last_actor_index = 0 @last_target_index = 0 @actors = [] @items = {} @weapons = {} @armors = {} endend

Código Ruby

Obviamente, la clase Game_Party no termina ahí, es solo un ejemplo, pasemos a explicarlo.

• attr_reader :gold: Permite LEER una variable de la propia clase desde otra clase ajena. Por lo tanto, puedes acceder desde cualquier clase a gold, pero solo para leerlo. Recuerda poner dos puntos ( : ) antes de la variable a atributar.

• attr_writer :var: Permite ESCRIBIR una variable de la propia clase desde otra clase ajena. Por lo tanto, puedes acceder desde cualquier clase a var, para escribir en ella. Recuerda poner dos puntos ( : ) antes de la variable a atributar.

• attr_accessor :last_item_id: Permite ESCRIBIR y LEER una variable de la propia clase desde otra clase ajena. Por lo tanto, puedes acceder desde cualquier clase a last_item_id, para leer y escribir en ella. Recuerda poner dos puntos ( : ) antes de la variable a atributar.

Lo que hace posteriormente dentro del método initialize (lo veremos mas adelante), es darle valor inicial a las variables, nada nuevo.

Lección VII: El Poder de RGSS2

– Comenzando con RGSS2

Bueno, por fin llegamos a RGSS2, de ahora en adelante, poco a poco nos iremos introduciendo en los comandos de RGSS2, revisando y explicando ciertas clases, como se crean escenas, ventanas, etc.

– Gráficos

¿Te imaginas un video juego sin gráficos? Creo que no. En RGSS2, es sumamente fácil crear y manipular un gráfico, vamos a la estructura:

Código Ruby

@sprite = Sprite.new@sprite.bitmap = Cache.picture(“nombre_del_archivo”)

Código Ruby

• @sprite = Sprite.new: Primero de todo, para crear un sprite, debes asignarlo a una variable, para posteriormente poder manipularlo. Así que en este caso le asignamos un nuevo sprite/imagen a la variable @sprite, la variable puede llamarse como quiera, no tiene porque llamarse así.Después, introducimos el signo de asignación (=), y a continuación el comando Sprite.new, esto si es obligatorio escribirlo tal cual está, crea un nuevo sprite/imagen.

• @sprite.bitmap = Cache.picture(“nombre_del_archivo”): Ahora, para cargar en este sprite, la imagen, simplemente ponemos el nombre de la variable a la que le asignamos un sprite nuevo anteriormente, un punto, seguido de bitmap, el signo de asignación (=), y a continuación Cache.picture (para acceder a un directorio se escribe Cache + . + el directorio sin “s”, o sea que si es Pictures, va a ser Cache.picture, si hay algún directorio que termine sin “s”, déjalo tal cual, como System, que queda exactamente igual, Cache.system).Después de este comando, entre paréntesis, va el nombre del archivo.

Existen ciertos métodos para poder manipular todo objeto (ventanas, sprites), no explicaré todos, pero si los más importantes y mas utilizados. Dejar claro que para utilizar los métodos, hay que escribir el nombre de la variable a la que le asignamos un sprite nuevo o una ventana, más un punto, más el método, todo seguido. Ahora si, pasemos a ver los métodos:

• .x: Con este método indicas la coordenada X para situar a tu gusto la imagen.• .y: Indica la coordenada Y de la imagen.• .z: Indica la coordenada Z de la imagen, la coordenada Z indica la posición de capa, si por

ejemplo, @sprite1.z = 1 y @sprite2.z = 2, y las dos se encuentran en la misma posición, @sprite2 se va a ver y @sprite1 no, porque la prioridad de visión (z) de @sprite2 es mayor.

• .opacity: Cambia la opacidad del objeto. 0-255• .visible: Aquí debes indicar con un true o false, si es true el objeto se mostrará, si es false, no lo

hará.• .update: Actualiza el objeto.• .dispose: Borra el objeto.

– Comandos más utilizados

Hay ciertos comandos que en casi todos los scripts se usan, como el de pulsar tecla y reproducir sonidos. Pasemos a ellos:

• Audio.se_play("Audio/SE/nombre_del_archivo”): Con este comando puedes reproducir un sonido SE. Si quieres reproducir un BGM o otro tipo de sonido, simplemente cambia Audio.bgm_play, o sea cambia donde dice el tipo de sonido, y pon el que necesites, y después (“Audio/TIPOSONIDO/nombre_del_archivo”).

• Input.trigger?(Input::LETRA): El Input.trigger? Sirve para asegurarse de una tecla presionada, se usa mucho en los menú y títulos. Reemplaza LETRA por la letra presionada, en mayúscula (C,X,A, y más) y no olvides situar los dos puntos (::) después del Input y antes de la LETRA.

Estos comandos son ajenos a herencias o demás clases. Son muy útiles a la hora de personalizar un buen sistema.

Lección VIII: Las Ventanas

– ¿Que son las ventanas en RGSS2?

Las ventanas en RGSS2 son bloques que pueden ser fácilmente manipulados. El bloque del Titulo donde eliges las opciones para jugar, es una ventana, las secciones del menú default son ventanas.Lo que pongas dentro de ellas, depende de ti.

– ¿Como creo una ventana?

¿Quieres crear una ventana? No hay problema, vamos a ello.Abre el RPG Maker VX, y entra al Editor de Scripts (F11).Crea una nueva página encima de Main (Insert), y llamala como quieras.El nombre de la página solo sirve para organizarte.Bueno, como sabrás, una ventana es una clase, comencemos a crearla:

Código Ruby

class Window_Sample < Window_Baseend

Código Ruby

Primero de todo comenzamos creando una nueva clase, el nombre no tiene porque comenzar con Window_, pero es recomendable para que no te confundas. Le pondremos de nombre a la ventana, Window_Sample, y heredaremos los métodos de Window_Base, mas tarde explicaré porque de Window_Base.

Posteriormente, vamos a crear un método dentro de la clase. Ese método se va a llamar initialize, debe ser obligatorio su nombre, lo explicaré cuando hable del Window_Base, así que por normas, le llamaremos al primer método, initialize:

Código Ruby

class Window_Sample < Window_Basedef initializeend

end

Código Ruby A continuación, dentro del método initialize, vamos a indicar los parámetros de super.El comando super contiene cuatro parámetros, el primero es X, se debe indicar la coordenada X donde la ventana se situará, en el segundo la coordenada Y, el tercer parámetro es width, o sea la base, el largo de la ventana, y el último y cuarto parámetro es height, que es la altura de la ventana. Con estos parámetros podemos jugar, manipulando las dimensiones y posición de la ventana.

Por lo tanto, el comando quedaría: super(x,y,base,altura)

Código Ruby

class Window_Sample < Window_Basedef initialize

super(70,100,400,20)end

end

Código Ruby

Lo que hicimos fue agregar el comando super, con sus respectivos parámetros, lo situamos en las coordenadas (70,100), con una base de 400 y una altura de 20 píxeles.Ahora vamos a crear otro método, donde dibujaremos un texto, le llamaremos refresh, no tiene porque llamarse a si, pero en la mayoría de las ventanas se encuentra. Así que, vamos a crearlo:

Código Ruby

class Window_Sample < Window_Basedef initialize

super(70,100,400,20)end

def refreshself.contents.clear

endend

Código Ruby

Bien, ya tenemos el nuevo método creado, e introducimos una nueva linea:self.contents.clearLo que hace esta linea lo podemos traducir perfectamente, ya hablamos antes de self, significaba YO, PROPIO, MIS, contents, significa contenidos, y clear, limpiar/borrar, entonces, mis.contenidos.limpiar, por lo tanto lo que hace es limpiar los contenidos de la ventana, te preguntarás porque limpiamos los contenidos si ni siquiera los hemos puesto. El tema esta en el update de la Escena que lo llama, imagina que tu ventana se llama desde Scene_Map, allí habrá un bucle (update) que actualizará los datos de tu ventana, por lo tanto, sino está el self.contents.clear, se escribirían arriba del anterior, y el juego puede desbordarse. Siempre en el método donde vayamos a dibujar los datos, introducimos un self.contents.clear.

Ahora pasemos al dato final, vamos a introducir un comando para insertar un texto dentro de la ventana:

Código Ruby

class Window_Sample < Window_Basedef initialize

super(70,100,400,20)

end

def refreshself.contents.clearself.contents.draw_text(120,0,100,100,"Aprende Ruby",1)

endend

Código Ruby

Bien, simplemente agregamos la siguiente línea:self.contents.draw_text(120,0,100,100,"Aprende Ruby",1)El comando draw_text de self.contents lo que hace es imprimir un texto pero en forma de gráfico, o sea no imprime un texto en una ventana default del sistema operativo como hace print, sino que lo hace en base a una fuente y lo introduce en los gráficos de la escena. Los parámetros del draw_text son fáciles:self.contents.draw_text(x,y,base,altura,”texto”,alineación)Tan fácil como eso. Indicar la coordenada X, la coordenada Y, la base del texto, o sea, el largo de la región del texto, el ancho de la región, el texto entre comillas (“”) y por último la alineación, si vale 0 es texto se sitúa a la izquierda, si vale 1 es centrado, y si vale 2 se sitúa a la derecha.

Ahora lo que tenemos que hacer, es llamar al método refresh, para que nos introduzca los textos y nos limpie los contenidos, quedaría así:

Código Ruby

class Window_Sample < Window_Basedef initialize

super(70,100,400,20)refresh

end

def refreshself.contents.clearself.contents.draw_text(120,0,100,100,"Aprende Ruby",1)

endend

Código Ruby

¡Listo! Has terminado tu primera ventana con éxito. Felicitaciones.Lo que contenga la ventana en un futuro depende de ti.

– ¿Como llamo una ventana?

Existen dos diferentes lugares para llamar a una ventana, puede ser desde una Scene, o desde el mapa con Llamar Script, pero de las dos formas es igual.

Para llamarla, debes asignarle a una variable, tu ventana. Por ejemplo:

@ventana = Window_Sample.new

Nunca olvides poner .new, ya que le estas indicando una nueva ventana, o sea una nueva Window_Sample, si no lo pones, te mandará error.Después como vimos antes, desde esa variable @ventana, puedes dimensionarla, como por ejemplo cambiarle sus coordenadas:@ventana.x = 100@ventana.y = 200

Tienes que poner exactamente lo mismo en Llamar Script, si es que quieres llamar la ventana desde un evento.

– Window_Base

Window_Base, es una clase como cualquier otra, pero tiene los métodos base para toda ventana, por eso es que siempre heredan de ella, contiene el initialize con todos los parámetros default, contiene métodos muy útiles como dibujar el nombre del héroe, la vida, o la clase:

• text_color(n): Con este método puedes cambiar el color de un texto cualquiera. Indicando en n el número del color.

• draw_icon(icon_index, x, y): Este método sirve para dibujar en la ventana un icono cualquiera, donde icon_index, indica el ID del icono, x e y, las coordenadas para situarlo.

• draw_face(face_name, face_index, x, y): Este método sirve para dibujar la Cara (Face) de cualquier persona o héroe dentro de la ventana, donde face_name va el nombre del archivo de las faces (Actor1, People1, etc), donde face_index, ahi va el ID de la Face dentro de la imagen de Faces, y después x e y como coordenadas para la ubicación.

• draw_character(character_name, character_index, x, y): Dibuja el gráfico de un character (personaje), donde character_name va el nombre del gráfico donde esta el character que quieres poner, donde character_index es el ID del personaje dentro de la imagen, y posteriormente las coordenadas x e y.

• draw_actor_graphic(actor, x, y): Dibuja el gráfico de uno de los personajes, donde actor debes indicar que actor es, pero no su ID, debes indicarlo de una forma de más compleja. En actor debes poner: $game_actors[id], ahora si, donde id, va el ID, del personaje, puedes asignarlo a una variable para no tener que ponerlo cada vez que uses un comando que requiera el ID del actor.

• draw_actor_face(actor, x, y): Dibuja el gráfico de la cara de cierto personaje, donde actor, va lo mismo que dijimos en el método anterior: $game_actors[id], después las coordenadas x e y para la posición.

• draw_actor_name(actor, x, y): Dibuja el nombre de cierto héroe, donde actor va lo mismo que dijimos en el método anterior, después las coordenadas x e y.

• draw_actor_class(actor, x, y): Dibuja la clase de cierto personaje, donde actor va de que héroe quieres que se sepa la clase, y posteriormente las coordenadas.

• draw_actor_level(actor, x, y): Dibuja el nivel de cierto personaje dentro del grupo, donde actor va de que héroe quieres saber el nivel, y los siguientes las coordenadas.

• draw_actor_state(actor, x, y): Dibuja el estado de cierto héroe, donde actor va de que héroe quieres que se sepa el estado, y después las coordenadas x e y.

• draw_actor_hp(actor, x, y): Dibuja el HP/VIDA, de cierto personaje, donde actor va de que héroe quieres que se sepa el HP/VIDA, y posteriormente las coordenadas para su posición.

• draw_actor_hp_gauge(actor, x, y): Dibuja la barra de vida de cierto personaje, donde actor va de que héroe quieres que se sepa la vida, y después las coordenadas x e y.

• draw_actor_mp(actor, x, y): Dibuja el MP/PODER MAGICO, de cierto personaje, donde actor va de que héroe quieres que se sepa el MP/PODER MAGICO, y posteriormente las coordenadas para su posición.

• draw_actor_mp_gauge(actor, x, y): Dibuja la barra de poder de cierto personaje, donde actor va de que héroe quieres que se sepa el poder mágico, y después las coordenadas x e y.

• draw_actor_parameter(actor, x, y, type): Dibuja cierto parametro indicado en type, donde actor va de que héroe quieres que se sepa el parámetro, x e y las coordenadas, y en type va un numero del 0 al 3, donde: 0 = ATK; 1 = DFS; 2 = SPI; 3 =AGI

• draw_item_name(item, x, y): Dibuja el nombre de cierto item, donde item, se indica el ID del item, posteriormente las coordenadas x e y.

Hay ciertos métodos que necesitan un parámetro actor, alli debes indicar lo siguiente:$game_actors[id]Donde id, va el ID de la Base de Datos de la sección Personajes, si es el principal, es 1.

Todos esos métodos pueden ser aplicados en cualquier ventana solo si la clase está heredada a Window_Base.

Lección IX: Las escenas

– ¿Qué es una escena?

En RGSS2, la escena lo es todo, el mapa es una escena, el título es una escena, pero solo puede haber una escena actual. La escena es también un objeto, y dentro de ella puede o no contener ventanas, en ella se actualizan, y se verifican datos para ejecutar instrucciones en un futuro.

– ¿Como llamo a una escena?

Ahora si, para llamar a una escena es distinto que para llamar a una ventana, es solo una pequeña diferencia.Para llamar a una escena, hay que asignarle a la variable global $scene, la escena que queremos ejecutar. Por ejemplo:$scene = Scene_Title.new

Así se llama también desde un comando Llamar Script. Recuerda que la variable global a asignar la nueva escena, siempre debe ser la variable $scene.

– ¿Como creo una escena?

Crear una escena no es nada del otro mundo. Es tan fácil como crear una ventana, con algunas excepciones, vamos a crear una escena, que salga un cartel en la punta arriba-izquierda que tenga un acceso rápido para salir del juego. Vamos paso a paso a crearlo:

Código Ruby

class Scene_Sample < Scene_Baseend

Código Ruby

Primero de todo creamos una clase, llámala como quieras, te recomiendo que el nombre comience con Scene_, para organizarte mejor. Heredamos los métodos de Scene_Base. Y seguimos.

Empezaremos la scene con un método llamado start:

Código Ruby

class Scene_Sample < Scene_Basedef start

op1 = “Seguir”op2 = “Ir al título”op3 = “Salir”@mapa = Spriteset_Map.new

@com = Window_Command.new(172,[op1,op2,op3])end

end

Código Ruby

Bien, vamos a explicarlo paso a paso.

• op1 = “Seguir”: Aquí lo que hicimos fue asignarle una cadena de texto (String) a una variable de método, ya que no la utilizaremos fuera de start. Estas variables locales/de método las utilizaremos para crear la ventana de comandos.

• @mapa = Spriteset_Map.new: Aquí lo que hacemos es llamar a un objeto, que es la función del Scene, juntar sub-objetos. En este caso le asignamos a una variable de clase, ya que la necesitaremos en los demás métodos para actualizarla (update), la clase Spriteset_Map, que es el mapa en general, poniendo esta línea en cualquier script, muestra el mapa de fondo, si no hubiéramos puesto esta linea, se vería un fondo negro con las opciones, y no las opciones con el mapa actual de fondo, puedes probar borrar esta linea cuando terminemos esta lección para ver el efecto.

• @com = Window_Command.new(172,[op1,op2,op3]): Aquí llamamos a otra clase más, que es Window_Command, esta clase crea una ventana según sus parámetros y le agrega un cursor para poder seleccionar opciones. Necesita parámetros, el primero es el largo de la ventana de comandos, en este caso le puse 172, me parecía justo. El segundo parámetro, debes indicar las opciones dentro de corchetes [], y separados por coma.

Bien, hasta aquí tenemos algo importante, pero todavía falta, sigamos:

Código Ruby

class Scene_Sample < Scene_Basedef start

op1 = “Seguir”op2 = “Ir al título”op3 = “Salir”@mapa = Spriteset_Map.new@com = Window_Command.new(172,[op1,op2,op3])

end

def update@mapa.update@com.update

endend

Código Ruby

Seguiré explicándote paso a paso:

• def update: Creamos otro método, esta vez se llama update, el método update es muy especial e importante, ya que está en constante repetición, por lo que su nombre dice, es sumamente útil para actualizar objetos.

• @mapa.update: Actualizamos @mapa, o sea Spriteset_Map, que es lo que le asignamos. Para actualizar cualquier objeto, se debe poner la variable en la cual se asigno, seguida de un punto y update.

• @com.update: Actualizamos @com, o sea la caja de comandos (opciones).• end: Obviamente, como todo método, termina en end.

Tenemos la caja con las opciones, y el mapa de fondo, lo único que nos queda es programar las instrucciones según la opción elegida, veamos lo que sigue:

Código Ruby

class Scene_Sample < Scene_Basedef start

op1 = “Seguir”op2 = “Ir al título”op3 = “Salir”@mapa = Spriteset_Map.new@com = Window_Command.new(172,[op1,op2,op3])

end

def update@mapa.update@com.updateif Input.trigger?(Input::C)

case @com.index when 0 @com.dispose $scene = Scene_Map.new when 1 @com.dispose $scene = Scene_Title.new when 2 exit end end

endend

Código Ruby

if Input.trigger?(Input::C): ¿Recuerdas esta línea? Por si no, lo que hace es asegurar una tecla presionada, y está en un condicional if, por lo tanto, significa si la tecla C, a sido pulsada, que se ejecute las siguientes lineas.

case @com.index: La siguiente línea al if anterior es un case, toma para verificar la variable @com.index, index significa punto de posición, o sea, en que opción se encuentra el cursor.

@com.dispose: Está linea lo que hace es borrar el objeto asignado a la variable @com, o sea borra la caja de opciones.

$scene = Scene_Map.new: Recordemos que $scene significaba la escena actual en que se está,

por lo tanto se reemplaza la escena por el Mapa y se vuelve al juego sin problemas.

exit: Este comando sirve para cerrar el programa terminando todos los procesos.

Como ven, me salté algunas lineas, porque ya me imagino que sabrán, hemos hecho ejemplos de los mismos anteriormente.

Pues bien, he terminado de explicar lo que es un Scene y un ejemplo completo. ¡Muy bien!Has creado tu propia ventana y tu propia scene. Resumen general de la Scene:

Primero de todo creamos la escena escribiendo la palabra reservada class y su nombre, posteriormente la heredamos a Window_Base para poder usar sus métodos.Creamos un método llamado start para crear las opciones del menú y llamar a los demás objetos.Creamos otro método llamado update, este método es especial porque está situado en una repetición constante, por lo que es sumamente útil para actualizar objetos. En ella, introducimos los métodos para actualizar el mapa y la caja de opciones.Después creamos un condicinal if para verificar si la tecla C se ah presionado.Dentro de ese condicional, anidamos un condicional case, para verificar donde estaba el cursor cuando se presionó la tecla C y ejecutar diferentes instrucciones según su posición.

Lección IX: Final de la guía

– Despedida y contacto

Bueno, la guía termina aquí, espero que hayan aprendido como utilizar sin problemas Ruby con RGSS2, espero también que se hayan divertido leyendo, y que se diviertan programando.

En mi opinión, siempre tuve ganas y ánimos para hacer una buena guía, pero nunca tuve tiempo.En estos últimos días se me he dado un poco de libertad y he creado esta guía sobre Ruby basada en RGSS2.

Si tienes alguna duda sobre Ruby o RGSS2 puedes contactarme a mi e-mail: necrozard@live.comO también puedes encontrarme en los foros de VoidZone4. Adiós.