¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Resultados de la Encuesta: ¿Qué te gustaría scriptear con tus propias manos?

69% | 9 Voto(s)
8% | 1 Voto(s)
8% | 1 Voto(s)
15% | 2 Voto(s)
Votos Totales : 13

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 RGSS3 Para principiantes - Parte VII el Miér Jul 15, 2015 4:04 am

Reputación del mensaje :100% (3 votos)

XSerozY

avatar
RGSS3 Para principiantes - Parte VII
Por XSerozY

Puedes ver la parte anterior del tutorial aquí , o si deseas empezarlo desde cero, puedes ver la primera parte aquí.

OJO: RGSS3 es el lenguaje usado en RPG Maker Ace, en XP, VX, etc, no funcionará! Aunque algunas cosas si son compatibles, pero el tutorial lo he hecho basándome en RGSS3. Puedes probar esto en otras versiones del Maker, pero no prometo que todo te funcione. Sin embargo, si sabes solucionar algún problema de compatibilidad, dímelo porfa n.n

¡Nuestro primer script!

Si has llegado a este punto del tutorial, toma un alien alien porque te lo ganaste Opalo Hola

Si aún te quedó alguna duda sobre lo visto en los anteriores tutoriales, vuelve y pregunta! No quiero que queden  problemillas flotando en tu mente Ópalo Aturdido

Ha llegado el momento de que crees tu propio script usando todo lo aprendido hasta ahora.

¿Y que mejor que destinar los próximos tutoriales a la creación de un script en específico?

Y llega el momento en que te pones a pensar.... ¿Qué podría ser útil? ¿Qué necesito para mi juego?

Eso depende de cada uno, claro está, pero para comenzar haremos algo sencillo, pero que nos pueda servir, claro está. Así que para comenzar:

Ópalo Aplaudiendo Crearemos una ventana emergente (pop up) que muestre un mensaje! Ópalo Aplaudiendo


Ya, muy útil no es Ópalo Sonrisa Grande, y quizás hayan muchos scripts así con muchas más opciones, pero es algo que a cualquiera le puede servir, y es sencillito de hacer.

¿Como comienzo a scriptear?

Una vez tengas la idea del script en tu mente, debes tener en cuenta algunas cosillas:

- Los scripts debes crearlo abajo de Materials y arriba de Main en el editor de scripts.

- Acostúmbrate a documentar tu script con comentarios. Los comentarios no interfieren con el funcionamiento del script, pero ayudan a mantenerlo ordenado y legible para el ojo humano, a parte de explicar  cosas como el funcionamiento del script, datos sobre el autor del script, etc.

Los comentarios puedes crearlos de dos formas.
La primera, es escribiendo el símbolo #. Entonces todo lo que esté a la derecha de aquel símbolo, se convertirá en un comentario. Ejemplo:

Código:
# Soy un comentario !
local = 1 # Soy otro comentario !

La otra forma de insertar comentarios, es escribiéndolos dentro de un bloque que comienza con =begin y termina con =end. Da igual cuantas líneas ocupemos, ya que todo lo que esté dentro de este bloque será un comentario. Ejemplo:

Código:
=begin
Soy un bloque de comentario.
Da igual cuantas líneas escriba,
todo lo que hay aquí dentro será
transformado en comentario.
=end

Otra cosa que deberías saber en el momento de crear un script, es, obviamente, saber scriptear. Así que comenzemos.

Módulos

Un módulo es un conjunto de métodos y/o variables que podemos usar en diferentes scripts y clases, algo así como una librería. No profundicemos más en el tema, y veamos como se crean:

module [NombreModulo]
#...
end

Para el nombre del módulo se aplican reglas como a las clases: Si hay dos o más módulos con el mismo nombre, estos se fusionarán, y si hay dos o más módulos con el mismo nombre y a su vez tienen dentro variables y/o métodos con el mismo nombre, estos se sobrescribirán.

Los módulos se pueden anidar, es decir, podemos crear un módulo dentro de otro.

Para usar una variable creada dentro de un módulo, lo hacemos de esta forma:

Código:
NombreModulo::NombreVariable

Por ejemplo, si tenemos dentro del módulo ModuloA una variable llamada NUMERO, para mostrarla en un cuadro de texto haríamos:

Código:
msgbox_p(ModuloA::NUMERO)

Dijimos que podíamos anidar módulos, osea, crear módulos dentro de módulos. Entonces si queremos mostrar en pantalla la variable NUMERO que se encuentra dentro de ModuloB y ModuloB a su vez está dentro de ModuloA, hacemos de forma similar:

Código:
msgbox_p(ModuloA::ModuloB::NUMERO)

Lo captas? Opalo Hola

Ventanas

Aunque aquí trato de explicar de la mejor forma posible, te aconsejo que veas como introducción este post creado por @"kyonides-arkanthos"

Nosotros para evitar confusiones crearemos nuestra ventana dentro de una clase:


Puedes notar ahí como documento mi script con comentarios Opalo Hola
Tranquis, ahora paso a explicar el script e.e

  - La clase se llamará Window_PopUp. Recuerda que el nombre es a elección propia ;D

  - Esta clase tendrá como superclase a Window_Base, que en Ace es la clase que contiene métodos ya hechos por los chicos de Enterbrain para facilitarnos la vida y la creación de ventanas. Casi todo lo que necesitemos para crear una ventana lo encontraremos en Window_Base, y recuerda que al asignarle una superclase a una clase, esta última hereda(o se copian) todos los métodos de la primera Opalo Hola

 - Sabemos que la función initialize es la que se inicia primero al momento de crear una instancia de la clase. Entonces... ¿Qué son todas esas variables locales que nos pide como argumento y que después se las pasa a super?

Una ventana se forma con 4 medidas:

  - X: Coordenada x en donde será creada la ventana.
  - Y: Coordenada y en donde será creada la ventana.
  - Width (Ancho): Ancho (Escala horizontal) de la ventana.
  - Height (Alto): Altura (Escala vertical) de la ventana.

Que tiene que ver eso?

Window_Base como es de esperar también contiene un método initialize y obviamente no lo queremos sobrescribir, así que por lógica usamos super para ejecutarlo antes de que lo sobrescribamos.

Y da la casualidad que el método initialize de Window_Base nos pide como argumentos aquellas medidas (x, y, width, height) <- en ese orden, entonces, en nuestra clase, debemos dárselas en los argumentos del super.

Y porqué en vez de escribir las medidas de nuestra ventana directamente en los argumentos del super hacemos que nuestro método initialize las pida?

Recuerda que una clase es como una plantilla o molde de algo. Window_Base es la plantilla para crear ventanas de forma general, y nuestra clase es la plantilla para crear una ventana PopUp. Se entiende?

Entonces, si nuestra clase pide sus propios argumentos, podemos crear diferentes PopUp con diferente posición, tamaño, etc. Y, como todos los argumentos son variables locales, usamos las variables x, y, w, h para referirnos a la coordenada x, coordenada y, width, height respectivamente.

Mostrando el PopUp

Si queremos que nuestro PopUp aparezca por medio de un script call (Osea, llamar a un script por medio de eventos), así como lo hacen todos los scripters profesionales, pues déjame decirte que hay muchas formas de hacerlo Ópalo Sonrisa Grande Pero la más.. emm... ¿amigable? Bueno.. la que más se usa, es creando un método en la clase Game_Interpreter.

Game_Interpreter es una de las muchas clases que vienen ya creadas junto con Ace pero esta es especial, ya que, y atención enginers, todo, y absolutamente todo lo que los eventos hacen, desde mostrar un mensaje hasta crear rutas de movimiento, todos los scripts que ejecutamos sin saberlo cuando creamos un evento, están dentro de la clase Game_Interpreter.

Suena lógico creer que creando un nuevo método en esta clase, podamos llamarlo fácilmente por medio de eventos, cierto? Opalo Hola

Vamos a ello!


Muy bien, creamos un método llamado show_popup, que nos pide dos argumentos: w = 200, h = 50.
Supongo que ya puedes intuir que w se usa como abreviación de width y h como abreviación de height, pero obviamente el nombre de aquellas variables puede ser el que quieras, siempre que recuerdes para que las creaste, claro está.

Las dos líneas siguientes las usamos para darle valor a x y a y. Muchas operaciones aritméticas, ¿eh? Estas podrían compararse con ecuaciones  en las que hay que reemplazar el valor de una(s) variable(s).

Graphics es.. un módulo, que procesa los gráficos del juego. width es un método de este módulo que devuelve el ancho total de la pantalla.. Osea, la resolución de esta. Por ejemplo, si la pantalla de tu juego está ajustada a una resolución de 640x480, el width de la pantalla sería 640.

Al igual que las clases, puedes llamar a aquel método escribiendo Graphics.width.

Por lógica, si escribimos en cambio Graphics.height se nos devolverá el alto de la pantalla del juego. Entonces  con la resolución 640x480 aquel método devolverá 480.

Volvamos al script. Cuando decimos (Graphics.width / 2) se nos devolverá el ancho de la pantalla dividido en dos, y si decimos (Graphics.height / 2) se nos devolverá el alto de la pantalla dividido en 2.

Adivina entonces donde se creará una ventana en la cual los valores x e y tengan aquellos valores.
Opalo Hola ¡Exacto! ¡La ventana se creará en el centro de la pantalla! Opalo Hola

Y ¿por qué a los valores x e y les restamos el ancho de la ventana partido en 2 y el alto de la ventana partido en 2 respectivamente?

Simplemente para ubicar el centro de la ventana en el centro de la pantalla. La ventana empezará a crearse en el punto x y en el punto y, y esta se dibujará hacia la derecha. Al restarle a estos valores el ancho y el alto, ubicamos el centro de la ventana en el punto en donde se empezó a crear la ventana, es decir, el centro de la pantalla.

Entonces, con la línea @popup = Window_PopUp.new(x, y, w, h) creamos nuestra ventana, y en el juego, sin darle valor a w y a h (usando los predeterminados) se ve así:


WOOOW! XSEROZ!!  SE VE.. SE VE... ES HERMOSAMENTE....

Opalo Enojado ¡¡¡¡¡¡¡ VACÍO !!!!!!! Opalo Enojado


Umm.. Ópalo:opmad:  tiene razón, nos falta lo principal: Agregarle el texto! Ópalo Sonrisa Grande!!!!!

¡Escribiendo texto!

Para esto, agregamos algunas líneas de código más al script:


En el método initialize agregamos el argumento text, el cual le daremos valor cuando creemos la ventana. Este valor, que es obviamente un texto, lo guardamos en la variable de instancia @text para usarlo más adelante.

Escribimos y llamamos un nuevo método: refresh, que podría traducirse como 'actualizar'. Este  método posiblemente lo encontrarás cuando sea necesario actualizar la ventana, cada cierto tiempo, pero esta vez lo usaremos para crear el texto en la ventana.

contents.clear lo que hace es limpiar o eliminar el contenido de la ventana, no queremos escribir cosas encima de otras, o si?

draw_text_ex es una forma fácil de escribir texto en una ventana. El primer y el segundo argumento de este método es la posición x e y que tomará el texto dentro de la ventana. Los valores son 0, lo cual quiere decir que el texto comenzará a escribirse de la esquina superior izquierda de la ventana.

El tercer argumento de draw_text_ex es, simplemente el texto a mostrar, que en este caso está dentro de @text.

Al método show_popup de Game_Interpreter simplemente le pedimos el argumento del texto, el cual debe ser especificado por el usuario, y lo agregamos a los argumentos de Window_PopUp.new, ya que en esa clase, initialize nos la pide, recuerdas?

¡Ahora sí! Probemos:


Bueno, increíble quizás no sea, y deja mucho que desear, pero para ser un script casero no está nada mal, además cumple muy bien su cometido !! Y si te sobra o te falta espacio para mostrar el texto, podemos darle valor a los demás argumentos del método show_popup, si, los que editan el ancho y el alto ! Ópalo Aplaudiendo Ópalo Aplaudiendo

El PopUp no se va....

¡Debemos eliminarlo! eso se hace así:

@popup.dispose

Y ya está!

Podemos hacer esto:


O crear un nuevo método en Game_Interpreter:


¿Y qué es ese .nil? Si ponemos aquel código como sufijo de algo, en este caso una ventana, se nos devolverá true si el objeto está vacío. Entonces, y como unless ejecuta acciones solo si la condición no se cumple (en este caso, la ejecutará solo si devuelve false, osea, cuando @popup no esté vacío)

Entonces podemos hacer esto:


Y ya está!!! Has creado tu propio script casero funcional!!! Ópalo Aplaudiendo Ópalo Aplaudiendo Ópalo Aplaudiendo

FIN!

Bien hecho, espero que este tutorial te sea de mucha ayuda! Hemos dado un primer paso al maravilloso mundo del scripting!

Aquí tienes el script completo. Fíjate que le he añadido un encabezado personal, que da información útil sobre el script. Quizás esté algo exagerado, pero te puede servir como modelo o base. Te recomiendo que hagas algo similar con los tuyos ;D

Código:
#==============================================================================
# ** PopUp
#  Author: XSerozY
#------------------------------------------------------------------------------
#  Este script muestra un PopUp mediante script calls.
#
#   Changelog:
#     ~ 14-07-2015: Inicio y fin del script.
#
#   Condiciones de uso:
#     ~ Para uso en juegos no comerciales. Para juegos comerciales, contact me.
#     ~ Eres libre de alterar el script a tu gusto.
#     ~ Bugs/Problemas de compatibilidad/Sugerencias son bienvenidos.
#     ~ NO puedes borrar este encabezado.
#     ~ No puedes decir en ningún sitio que este script es de tu propiedad.
#     ~ Da créditos a XSerozY en tu juego.
#
#   Instalación:
#     ~ Copia y pega el script abajo de "Materials" y arriba de "Main".
#
#   Requisitos:
#     ~ Ninguno.
#
#   Compatibilidad:
#     ~ Ningún problema conocido.
#
#   Uso:
#     ~ Usa los siguientes script calls:
#
#         show_popup(text,width,height)
#           * Muestra un PopUp. El width y el height es opcional.
#
#         delete_popup
#           * Elimina el actual PopUp.
#
#==============================================================================

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  ▼ class Window_PopUp
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Window_PopUp < Window_Base
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h, text)
    super(x, y, w, h)
    @text = text
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    draw_text_ex(0, 0, @text)
  end
  
end # class Window_PopUp


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  ▼ class Game_Interpreter
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Show PopUp
  #--------------------------------------------------------------------------
  def show_popup(text, w = 200, h = 50)

    x = (Graphics.width  / 2) - (w / 2)
    y = (Graphics.height / 2) - (h / 2)
    
    @popup = Window_PopUp.new(x, y, w, h, text)
  end
  #--------------------------------------------------------------------------
  # * Delete PopUp
  #--------------------------------------------------------------------------
  def delete_popup
    @popup.dispose unless @popup.nil?
  end
  
end # class Game_Interpreter





Dudas? Sugerencias? Errores míos que no ví? Cualquier cosa? Dímelos ! Opalo Hola

No olvides contestar la encuesta, exprésate! Este curso es tu lugar para aprender!

En el próximo tema...
Eso lo decidirán ustedes  Ópalo Buscapleitos

Saludos!!^^



Última edición por XSerozY el Miér Jul 15, 2015 11:22 pm, editado 1 vez

#2 Re: RGSS3 Para principiantes - Parte VII el Miér Jul 15, 2015 4:54 pm

reyerta

avatar
Increíble!!! traté de repetir los pasos en el xp y no pude T_T ¡pero no me rendiré! aprenderé a hacer un script con mis propias manos *snif* *snif* nunca creí que vería el día donde podría intentar hacer un script desde cero... ¡Gracias XSerozY!


Lo conseguiré y cuando lo haga actualizaré este mensaje mostrando mi propio script!!!

Sobre la encuestas (aunque ya deje mi voto). Creo que seria increíble hacer un menú, es una constante en los juegos RPG y que mejor que tener uno creado por ti mismo en vez de una adaptación del menú de alguien mas.

Increíbles clases, te dejo un súper merecido punto de reputación y estaré esperando con muchas ganas el próximo curso.

#3 Re: RGSS3 Para principiantes - Parte VII el Jue Jul 16, 2015 12:16 am

XSerozY

avatar
@reyerta escribió:Increíble!!! traté de repetir los pasos en el xp y no pude T_T ¡pero no me rendiré! aprenderé a hacer un script con mis propias manos *snif* *snif* nunca creí que vería el día donde podría intentar hacer un script desde cero... ¡Gracias XSerozY!

Creo que te eh ganado:



Te recomiendo que te guíes en el tutorial de Kyonides http://www.universomaker.net/t3221-ventanas-iconos-y-sprites

Igualmente te diré que ocurrió:

Hacerlo funcionar en XP

Si no me equivoco, en XP debes crear el contenido de la ventana. ¿Cómo hacemos eso? En el método initialize de la clase Window_PopUp debajo del super agrega:

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

self.width y self.height los usamos para referirnos al ancho y al alto de la ventana respectivamente (self lo usamos para referirnos al objeto actual, en este caso, a la ventana)

Y porqué le restamos 32? Para que no se vea así:


Es un problema de los bordes, que kyo te explica en su post.

Entonces, siempre que queramos hacer algo dentro del contenido de la ventana, anteponemos el self.contents.

Por ejemplo, en vez de contents.clear, usamos self.contents.clear
En vez de draw_text_ex usamos self.contents.draw_text_ex.

Y sobre  el draw_text_ex.. ese método al parecer no existe en XP, de manera que usaremos el draw_text (que también existe en Ace y en VX). A diferencia de draw_text_ex, draw_text nos pide los siguientes argumentos:

Código:
draw_text(x, y, width, height, text, alignment)

x, y, width y height son las medidas del texto Opalo Hola al igual que las ventanas. Recuerda que si x e y son 0, el texto debería comenzar desde la esquina superior izquierda de la ventana.

alignment es opcional, e indica la alineación del texto. Si es 0, el texto estará alineado a la izquierda. Si es 1, el texto estará centrado, y si es 2, este estará alineado a la derecha. Por defecto, viene con valor 0.

Otra cosa: En XP, la clase Game_Interpreter se llama simplemente Interpreter.

Y tampoco se puede hacer Graphics.width o Graphics.height, de manera que si quieres centrar la ventana, deberás escribir manualmente el ancho y el alto de tu juego. Por defecto creo que la resolución del XP es  640x480, así que reemplazando Graphics.width por 640 y Graphics.height por 480, debería funcionar.

Fin

Prueba ahora, con estos nuevos conocimientos, a scriptearlo en XP Opalo Hola Opalo Hola

Por si te rindes, o ya lo lograste, aquí abajo te dejo el script en XP:

NO ABRIR:

Código:
#==============================================================================
# ** PopUp
#  Author: XSerozY
#------------------------------------------------------------------------------
#  Este script muestra un PopUp mediante script calls.
#
#   Changelog:
#     ~ 14-07-2015: Inicio y fin del script.
#
#   Condiciones de uso:
#     ~ Para uso en juegos no comerciales. Para juegos comerciales, contact me.
#     ~ Eres libre de alterar el script a tu gusto.
#     ~ Bugs/Problemas de compatibilidad/Sugerencias son bienvenidos.
#     ~ NO puedes borrar este encabezado.
#     ~ No puedes decir en ningún sitio que este script es de tu propiedad.
#     ~ Da créditos a XSerozY en tu juego.
#
#   Instalación:
#     ~ Copia y pega el script abajo de "Materials" y arriba de "Main".
#
#   Requisitos:
#     ~ Ninguno.
#
#   Compatibilidad:
#     ~ Ningún problema conocido.
#
#   Uso:
#     ~ Usa los siguientes script calls:
#
#         show_popup(text,width,height)
#           * Muestra un PopUp. El width y el height es opcional.
#
#         delete_popup
#           * Elimina el actual PopUp.
#
#==============================================================================

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  ▼ class Window_PopUp
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Window_PopUp < Window_Base
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h, text)
    super(x, y, w, h)
    self.contents = Bitmap.new(w -32, h -32)
    @text = text
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.draw_text(0, 0, self.width, 32, @text, 1)
  end
  
end # class Window_PopUp


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  ▼ class Interpreter
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Interpreter
  #--------------------------------------------------------------------------
  # * Show PopUp
  #--------------------------------------------------------------------------
  def show_popup(text, w = 250, h = 60)

    x = (640  / 2) - (w / 2)
    y = (480  / 2) - (h / 2)
    
    @popup = Window_PopUp.new(x, y, w, h, text)
  end
  #--------------------------------------------------------------------------
  # * Delete PopUp
  #--------------------------------------------------------------------------
  def delete_popup
    @popup.dispose unless @popup.nil?
  end
  
end # class Interpreter

Saludos!!

Contenido patrocinado


Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.