1. No category

Tutorial para aprender a crear
scripts en RGSS by MakerJ
Obra bajo licencia Creative Commons 3.0, totalmente prohibida su distribución sin reconocer
al autor del mismo (MakerJ).
Queda totalmente prohibida su edición sin permiso expreso del autor. Prohibido su uso con fines comerciales.
Creado por MakerJ para la comunidad de Cedexia
Breve Introducción y Agradecimientos:
Este manual fue creado por mi(MakerJ) para la gran comunidad de creación de videojuegos Cedexia.
Para crear este manual tomé como referencia la guía de Necrozard, algunos apuntes de Dublebeax y la guía de
DonBarksGueist, además de mis propios conocimientos a lo largo de todos estos años como maker.
Este guía a sido creada sin ánimo de lucro y se puede distribuir siempre y cuando se indique el autor o un enlace a la
web del mismo (Cedexia).
Espero que con esta guía el que la lea aprenda a programar en RGSS aunque sean las nociones básicas.
¿QUE ES RGSS?
RGSS son las siglas de Ruby Scripting System o lo que es lo mismo: Sistema de Scripting para juegos con Ruby.
No voy a explicar que es un lenguaje de programación porque parto de la base de que sabeis que es, pasemos a
explicar que es el lenguaje de programación 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.
¿PROGRAMACIÓN ORIENTADA A OBJETOS? EN ESPAÑOL, POR FAVOR….
La programación orientada a objetos “POO” (OOP en inglés) es un paradigma de programación que usan los
principales lenguajes de programación, en este paradigma se usan objetos y sus relaciones para programar lo que
será la aplicación final.
Los objetos son entidades que combinan estado (atributo), comportamiento (método) e identidad, esto lo
aprenderemos mas adelante en la guía.
¿Y ESTO DE QUE ME SIRVE?
Principalmente para crear tu propio juego totalmente personalizado, un juego de Rpg Maker XP sin scripts no es
nada, cuando creas un nuevo proyecto este ya viene preparado con sus scripts básicos, si los borras el proyecto no
funcionará.
¿Y QUE PUEDO HACER CON RGSS?
TODO, respuesta simple y rápida.
Con RGSS puedes programar scripts que te permitan hacer todo lo que quieras siempre que sea posible que el Rpg
Maker lo haga funcionar con fluidez y que tu PC tenga los medios para hacerlo posible.
¿ESTÁS SEGURO QUE UN TONTO COMO YO PUEDE APRENDER ESTO?
Por supuesto, programar RGSS es una de las cosas más fáciles que puedes hacer en informática, en cuanto aprendas
lo básico y practiques un poco podrás dominarlo sin problemas.
Pasemos ya a la parte de programación.
VEO COLORES EN EL EDITOR…
El editor de scripts lleva incorporada la función de colorear los diferentes tipos de elementos del script.
Aprenderse estos colores es muy útil para programar con mayor rapidez:
• 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”
ELEMENTOS DE PROGRAMACIÓN.
-VARIABLES:
En el editor del Rpg Maker es posible insertar variables en un evento y aunque son un poco limitadas el concepto es
más o menos el mismo que 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. Como ya sabemos, las variables almacenan y devuelven valores. Es posible (o no)
modificar su valor, pero nunca el tipo de variable.
Pasemos a ver los diferentes tipos:
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
Instanciables: se pueden acceder a ellas en cualquier lugar de la clase (hablaremos más delante de ello). Declaración
en RGSS: @variable_instanciable=1
Arrays: este tipo de variable almacena muchos valores en una cadena. Por supuesto, los arrays pueden ser de los 4
tipos de variable citados anteriormente. Declaración en RGSS: array=[“hola”,”titis”,”mundo”]
Acceso de variable: array[0] accederá al valor “hola”, array[1] a “titis” y array[2] a “mundo”, mucho ojo porque, en
primer lugar, las cadenas se cuentan desde 0 (0 es el primer valor del array y asi) y acceder a un valor del array
inexistente puede generar un error de excepción al ejecutar.
-CONSTANTES
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. Los valores constantes tienen un valor determinado por código. Pueden declararse tanto fuera de
una clase como dentro de ella.
La mayor diferencia es que se escribe en mayúsculas:
EJEMPLO:
MAX_MAKERS, CONST
-OPERADORES
Son simples símbolos que se usan en programación para realizar operaciones matemáticas, una de las cosas mas
fáciles de aprender.
Elementos:
+ Suma
- Resta
* Multiplicación
/ División
+= sumar variable con valor asignado
-= restar variable con valor asignado
*= multiplicar variable por valor asignado
/= dividir variable por valor asignado
= asignar valor
== equiparar un valor con otro
!= un valor es distinto de otro
> Valor mayor a otro
< Valor menor a otro
>= valor mayor o igual a otro
<= valor menor o igual a otro
! Negar un valor
-ARRAYS
Es un tipo de variables que almacena valores en una misma cadena y estos se pueden leer y escribir.
La ventaja de usar arrays es que puedes tener la cantidad de variables que quieras en un solo
Conjunto.
Ejemplo:
@makers = [“MakerJ”,”Cedexia”,”Comunidad”]
print @makers[0]
print @makers[1]
print @makers[2]
@makers[0] = “Administrador_Cedexia”
@makers = [“MakerJ”,”Cedexia”,”Comunidad”] : Hemos asignado en una array 3 valores de tipo string
(texto).
Print @makers [0] Con esta line la estamos diciendo al programa que imprima en pantalla un texto
usando la función print, el texto que se imprimirá será en este caso el indicado en la línea, o sea al poner
el número 0 no está diciendo que imprima en pantalla el nombre MakerJ, esto pasa porque en
programación se empieza a contar desde el 0, si entre corchetes hubiéramos puesto 1 en pantalla se
mostraría el nombre Cedexia.
@makers[0] = “Administrador_Cedexia” : Esto lo que hace es simplemente cambiar el valor del primer
nombre, ahora ya no sería MakerJ sinó Administrador_Cedexia, entonces al array final quedaría así:
@makers = [“Administrador_Cedexia”,”Cedexia”,”Comunidad”]
Esto es una demostración de como mediante un array podemos dar y modificar valores, creo que lo he
explicado suficientemente para que sea entendible.
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 está 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:
@makers = {“MakerJ” =>”Admin”,”Cedexia”=>”Web”,”Albert”=>”Mod”}
print @makers[“MakerJ”]
@makers = {“MakerJ” =>”Admin”,”Cedexia”=>”Web”,”Albert”=>”Mod”}
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 @makers[“MakerJ”]
Es muy simple, lo que hace es imprimir por pantalla el valor que hemos asignado al nombre MakerJ dentro de la
tabla, en este caso el valor es Admin.
Si pusiésemos Cedexia nos devolvería el valor web y con Albert nos diría Mod.
Es fácil y muy simple de entender.
CONDICIONALES
Como su nombre indica son elementos que guardan una condición y que harán algo si esa condición se cumple (o si
hay excepciones) de lo contrario se ignorará y se seguirá adelante con el siguiente código.
CONDICIONAL IF
Este es probablemente el condicional más común y usado en cualquier lenguaje de programación.
Si se ejecuta su condición o excepción se ejecutará lo que haya declarado en dicha condición o excepción:
@persona1 = MakerJ
@persona2 = Albert
if @persona1 == @persona2
print “Ambas personas son la misma”
else
print “Personas diferentes”
end
Este ejemplo de condicional if lo que nos dice es que hemos declarado el valor persona1 que es igual a MakerJ y
persona 2 que es igual a Albert.
Empezamos el if con la operación @persona1==@persona2 y debajo la operación de imprimir en pantalla el texto
“Ambas personas son la misma”
Este texto se imprimiría en pantalla en el caso de que los 2 valores fueran iguales, pero como en este caso son
distintos el programa seguirá adelante con el código.
Mas abajo encontramos un else que es la palabra que declara la excepción, en este caso “Personas diferentes”.
La excepción se cumplirá en el caso de que la condición no sea cumplida y como no lo fue, se imprimirá en pantalla
el texto “Personas diferentes”
Acabamos el condicional con la palabra end, 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.
CASE
Parecido a if, pero se puede tener numerosas condiciones, incluida una excepción. También es posible usar rangos.
case @command_window.index
when 0
command_new_game
when 1
command_continue
when 2
command_shutdown
end
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:
@nombre = “MakerJ”
unless @nombre == “MakerJ”
print “¡Si no eres MakerJ no me hables!”
end
@nombre = “MakerJ”: Asignamos a @nombre, la cadena de texto “MakerJ”.
unless @nombre == “MakerJ”: La palabra unless significa “A menos que”, por lo tanto,
traducido sería “A menos que” la variable @nombre sea igual a “MakerJ” no se ejecuten las
instrucciones. Entonces, si el valor de la variable @nombre no es “MakerJ”, 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 eres MakerJ no me hables!”: Por lo tanto, si @nombre es igual a “MakerJ”, es
falso, se imprimirá por pantalla “¡Si no eres MakerJ no me hables!”. Fácil, ¿verdad?.
end: Por supuesto, como todo condicional, lo terminamos con un end.
BUCLE FOR
Permite repetir una misma instrucción un número determinado de veces y desde un punto determinado hasta otro.
Dichos puntos de comienzo y fin del bucle pueden ser números o variables numéricas.
for i in 0..10
print i
end
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 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 == 10
print “@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 == 10
print “@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: <=
Clases y métodos
Son el cuerpo y alma del scripting. Las clases son objetos que llamaremos para hacer la “magia”. Dentro de dicha
clase encontramos los métodos. Los métodos contienen las instrucciones que creamos y vamos a mandar al
intérprete. Para que éste las ejecute. Una clase puede tener atributos, al igual que los métodos. En principio, si
existen atributos éstos se deben “rellenar” con un valor al llamar scripts, de lo contrario, generara un error de
excepción al ejecutar. Bien antes de nada, nuestra clase (casi siempre) debe tener un método por defecto llamado
initialize. Ahí es donde pondremos nuestros atributos de acceso a la clase, y también ejecutaremos código una vez
inicializado el script.
class Clase_Marras #he notado que hay que poner en mayúsculas la primera letra de la
clase para que no de problemas de sintaxis
attr_accessor :greeting
attr_accessor :name
#los atributos en cuestión
def initialize(greeting, name) # el método de inicialización junto
con sus atributos
@greeting=greeting
@name=name
end
def say
print @greeting + " " + @name
end
# método que se puede llamar
end
Herencia de Clases:
Eres hijo único, tu padre muere y heredas sus pertenencias. Es una forma simple de explicarlo.
Para que una clase herede de otra, debemos poner esto:
class Clase_Marras < Windows_Base
Este ejemplo te permitiría, por ejemplo usar el sistema de ventanas para mostrar textos, ventanas y más cosas. Ideal
para crear vuestro propio sistema de menú personalizado.
Pero todavía no hemos terminado. Debemos inicializar la clase padre cuando la necesitemos. Ya que
Windows_Base te permite crear ventanas y tiene ciertas propiedades obligatorias para su creación (posición x,
posición y, ancho, alto).
En el método de inicializar metemos:
super(0, 0, 200, 200)
Aquí es de cuando acabamos con la teoría y pasamos a una parte más práctica , que ya iba siendo hora.
GRÁFICOS Y IMÁGENES
Todo juego sea del tipo que sea debe tener gráficos, un juego que no los tenga no puede llamarse juego propiamente
dicho.
En esta lección aprenderemos a insertar gráficos y como debemos utilizarlos:
@sprite = Sprite.new
@sprite.bitmap = Cache.picture(“nombre_del_archivo”)
@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 que utilizaremos en el script.
MANIPULAR GRÁFICOS
Como no siempre quedan las imágenes como queríamos o donde queríamos, tenemos a nuestra disposición algunos
códigos para ayudar. Para utilizar estos 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.
Aquí dejo algunos:
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.
REPRODUCIR AUDIO
Comp un juego sin audio queda sos, aquí os dejo el comando para reproducirlo:
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”).
PULSAR UNA TECLA
Normalmente cualquier script necesita que oprimamos alguna tecla, para ello está este script:
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
VENTANAS
Este tipo de ventanas no tiene nada que ver con las de tu casa.
Estas son bloques en los que se muestra lo que tu elijas desde el propio script.
¿Y COMO HAGO UNA?
¿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:
class Window_Sample < Window_Base
end
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, así que por normas, le llamaremos al primer método, initialize:
class Window_Sample < Window_Base
def initialize
end
end
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)
class Window_Sample < Window_Base
def initialize
super(70,100,400,20)
end
end
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:
class Window_Sample < Window_Base
def initialize
super(70,100,400,20)
end
def refresh
self.contents.clear
end
end
Bien, ya tenemos el nuevo método creado, e introducimos una nueva linea:
self.contents.clear
Lo 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 está 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:
class Window_Sample < Window_Base
def initialize
super(70,100,400,20)
end
def refresh
self.contents.clear
self.contents.draw_text(120,0,100,100,"Aprende Ruby",1)
end
end
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í:
class Window_Sample < Window_Base
def initialize
super(70,100,400,20)
refresh
end
def refresh
self.contents.clear
self.contents.draw_text(120,0,100,100,"Aprende Ruby",1)
end
end
con esto acabas de crear tu propia ventana, cuando tengas mas conocimientos podrás poner todo lo que desees en
ella.
LLAMAR TU NUEVA Y PRECIADA 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 =200
@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.
Estos métodos son básicos y muy fáciles de recordar.
ESCENAS
Las escenas lo son todo tanto en Rpg Maker XP como en VX.
El título es una escnea, el mapa también, también puede ser un objeto, pero solo puede haber una escena actual.
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.
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:
class Scene_Sample < Scene_Base
end
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:
class Scene_Sample < Scene_Base
def start
op1 = “Seguir”
op2 = “Ir al título”
op3 = “Salir”
@mapa = Spriteset_Map.new
@com = Window_Command.new(172,[op1,op2,op3])
end
end
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.
= 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.
• @mapa
• @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:
class Scene_Sample < Scene_Base
def 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
end
end
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:
class Scene_Sample < Scene_Base
def 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
if 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
end
end
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.
RESUMIENDO
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.
CREANDO NUESTRO HOLA CEDDEXIA!
Como en cualquier método de programación lo primero que se hace es crear un hola mundo nosotros no vamos a ser
menos ^^
Un hola mundo es una ventana que nos muestra un texto con la frase “Hola Mundo”, pero como eso ya está muy
visto nosotros crearemos nuestro propio “Hola Cedexia”
Pues vamos a ello, vamos al editor de scripts y creamos un script encima de main donde ponemos lo siguiente:
class Hola_Cedexia < Window_Base
def initialize
super(0, 0, 200, 200)
self.contents = Bitmap.new(width-32, height-32) #creamos un nuevo mapa de bits donde dibujar nuestro texto
self.contents.font.name = "Comic Sans MS"
self.contents.font.size = 24
self.contents.draw_text(0, 0, 200, 32, "¡HOLA CEDEXIA!") end
end
Creamos otro script y lo llamamos Mostrar_cedexia
class Mostrar_Cedexia
def main a
@window_1=Hola_Cedexia.new
Graphics.transition
loop do
Graphics.update
Input.update
@window_1.update
if Input.trigger?(Input::A) #si pulsamos el Z en nuestro teclado, la ventana desaparecerá y volveremos a
controlar al personaje
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
break
end
end
Graphics.freeze
@window_1.dispose
end
end
Echo todo esto solamente tendremos que crear un evento en el juego donde llamemos este script:
mostrar=Mostrar_Cedexia.new
mostrar.main
Y asegurarnos de que lo activamos en el juego.
Con esto ya habríamos creado nuestro propio “Hola Cedexia”
¿YA ESTÁ?
Si, con todo lo que te he ensañado en esta guía puedes hacer prácticamente lo que quieras siempre que utilices bien
los códigos y lo hagas con cabeza.
Ahora mismo eres un erudito del RGSS (si lo has entendido todo) por eso espero que sepas utilizar esos
conocimientos para hacer algún buen proyecto.
YA TENGO MI SUPERPROYECTO LLENO DE SCRIPTS PROPIOS! ¿AHORA QUE?
Pues ahora que ya has conseguido crear tu juego, te recomiendo que vayas por algunos foros y lo enseñes a los
demás usuarios para que te comentes sugerencias y fallos que pueda tener, recuerda que el script perfecto no existe,
siempre puede haber algún fallo.
Puedes postearlo en un foro especializado en creación de videojuegos como por ejemplo Cedexia:
http://cedexia.saapy.com o http://cedexia.saapy.com/foro
FINAL DE LA GUÍA
Aquí es donde acaba mi guía para aprender RGSS orientado a Rpg Maker XP.
Después de estar unas cuantas horas pegado a la pantalla escribiendo lo que acabas de leer quiero dar por finalizado
mi trabajo.
Esta guía a sido creada por mi para el foro de Cedexia.
Finalemente me gustaría dar las gracias a todos los usuarios de Cedexia por hacer posible este proyecto.
Si quereis ver mas manuales como este, preguntar dudas, hacer sugerencias, postear vuestros juegos o lo que sea os
recomiendo registraros en : http://cedexia.saapy.com
Podeis contactarme en el foro de cedexia o mediante el siguiente mail: [email protected]
HASTA LA PROXIMA!
Obra bajo licencia Creative Commons 3.0, totalmente prohibida su distribución sin reconocer
al autor del mismo (MakerJ).Queda totalmente prohibida su edición sin permiso expreso del autor. Prohibido
su uso con fines comerciales.