Veremos lo que son lo attr , estos son Variables globales, y son 3 writer, accesor y reader, cada uno de ellos hace una funcion distinta en el programa:
attr_writer :nombre_cualquiera = lo que hace es escribir un valor en la variable global, por tanto el programa no lo lee.
attr_reader :nombre_cualquiera = lo que hace es leer el valor de la variable, por tanto no se puede escribir.
attr_accesor :nombre_cualquiera = lo que hace es leer y escribir en la variable global.
Para guardar un valor, tan solo se debe guardar como variable de metodo, de esta manera:
class Game_System
#--------------------------------------------------------------------------
attr_accessor :archivo_acceder
#--------------------------------------------------------------------------
alias mono_gamesystem_initalize_attr initialize
def initialize
@archivo_acceder = "hola"
mono_gamesystem_initalize_attr
end
end
De esta manera podemos ver que para guardar el valor en la variable, ponemos el mismo nombre de attr como variable de metodo y luego guardarmos lo que queramos.
Si queremos cambiarlo, podemos colocar un evento en el mapa, luego scripts y ponermos alli msgbox_p($game_system.archivo_acceder) y nos saldra una ventana con lo que dice, para cambiarlo simplemente lo llamamos y sobre escribrimos asi $game_system.archivo_acceder = "lo que sea" y luego ponemos denuevo msgbox_p($game_system.archivo_acceder) y ahi nos daremos cuenta que habrá cambiado el valor.
Aprendiendo Ruby para RMVX
miércoles, 28 de agosto de 2013
Mensajes
Hola a todos los que siguen el blog, ya se que ah estado un poco retrasado, pero es que ya tengo algunas cosas que hacer en mi vida y en la universidad, asi que ando un poco ocupado, sin embargo intentare actualizar el blog lo mas seguido posible y en cuanto pueda, antes del dia domingo de cada semana verán a lo menos una leccion o concepto basico, etc. para que no se desesperen, o los vean los domingos todos...
Otra cosa es que sacaré un archivo pdf con todos los conceptos basico hasta ahora, que son 10 con el que viene, son bastantes cosas, todas importantes y es mejor que los tengamos a mano.
Así que espero que no se vayan, porque aun no terminamos y puede que editemos un poco mas adelante algun script que queramos sin ayuda de un video, pero para eso necesito ideas, obviamente no tan extremos como un sistema de batalla, o un menu, sino que cosas pequeñas o detalles por ahora como hicimos para colocar sonido a las cosas, etc.
Eso es todo, no seguiremos viendo...
Otra cosa es que sacaré un archivo pdf con todos los conceptos basico hasta ahora, que son 10 con el que viene, son bastantes cosas, todas importantes y es mejor que los tengamos a mano.
Así que espero que no se vayan, porque aun no terminamos y puede que editemos un poco mas adelante algun script que queramos sin ayuda de un video, pero para eso necesito ideas, obviamente no tan extremos como un sistema de batalla, o un menu, sino que cosas pequeñas o detalles por ahora como hicimos para colocar sonido a las cosas, etc.
Eso es todo, no seguiremos viendo...
viernes, 23 de agosto de 2013
Lección 6: Sprites y Texturas
Esta vez aprenderemos a colocar imagenes y sprites en los menus y opciones, les dejo el video de diamondandplatinum3 en ingles y luego lo analizamos
Comenzaremos con el script de la clases anteriores, se los dejo aca para que no lo busquen :
Comenzaremos con el script de la clases anteriores, se los dejo aca para que no lo busquen :
class Scene_Mono < Scene_Base
#--------------------------------------------------------------------------
# ● Start
#--------------------------------------------------------------------------
def start
super()
@ventana = Window_Help.new
end
#--------------------------------------------------------------------------
# ● Post_start
#--------------------------------------------------------------------------
def post_start
super()
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
super()
return_scene if Input.trigger?(:B)
end
#--------------------------------------------------------------------------
# ● Pre-terminate
#--------------------------------------------------------------------------
def pre_terminate
Sound.play_cancel
end
#--------------------------------------------------------------------------
# ● Terminate
#--------------------------------------------------------------------------
def terminate
super()
@ventana.dispose
end
end
#=============================================================================
# WINDOW
#=============================================================================
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
#=============================================================================
# SCENE
#=============================================================================
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
def command_Nuevo #~Que pasa si aprieto en la opcion
SceneManager.call(Scene_Mono)
end
end
#=============================================================================
Ahora nos concentraremos en nuestro metodo estar de la escene, crearemos una variable de metodo y le pondremos cualquier nombre, pero ojala algo relacionado con los sprites, el mio sera @misprite y llamaremos para que genere una nueva funcion de sprites @misprite = Sprite.new() y luego con la misma variable de metodo la copiamo y pgamos debajo y le pondremos .bitmap , que es el que genera la imagen por asi decirlo.
tendremos lo siguiente:
#--------------------------------------------------------------------------
# ● Start
#--------------------------------------------------------------------------
def start
super()
@misprite = Sprite.new()
@misprite.bitmap
Despues de la extension .bitmap, llamaremos el archivo imagen, esta imagen puede estar en cualquier carpeta de la carpeta Graphics, en este caso, pondremos una en la carpeta pictures, entonces nuestro metodo quedará = Cache.picture(" nombre de la imagen sin la extension ").
Una vez hecho eso, veremos como colocarla en la pantalla utilizando los comandos x, y y z ,para eso copiamos nuestra variable @misprite y le ponemos la extension .x para moverla horizontalmente y .y para moverla verticalmente. La cantidad de espacio que hay en la ventana del juego horizontalmente es de 544 pixeles y de alto 414 pixeles, por lo que uno puede jugar con eso. si ponemos .z lo que veremos es la profundidad que va la imagen, si se pone una encima de otra. En este caso le pondran el valor que ustedes quieran.
Luego de esto como no desaparece la imagen, debemos decirle al juego que lo haga, buscarmos la parte terminate y pondremos nuestras variable @misprite y @misprite.bitmap con la extension .dispose, quedaria de esta manera
#--------------------------------------------------------------------------
# ● Start
#--------------------------------------------------------------------------
def start
super()
@misprite = Sprite.new()
@misprite.bitmap = Cache.picture("IMG_20130818_184618")
@misprite.x = 200
@misprite.y = 0
@ventana = Window_Help.new
end
#--------------------------------------------------------------------------
# ● Post_start
#--------------------------------------------------------------------------
def post_start
super()
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
super()
return_scene if Input.trigger?(:B)
end
#--------------------------------------------------------------------------
# ● Pre-terminate
#--------------------------------------------------------------------------
def pre_terminate
Sound.play_cancel
end
#--------------------------------------------------------------------------
# ● Terminate
#--------------------------------------------------------------------------
def terminate
super()
@ventana.dispose
@misprite.dispose
@misprite.bitmap.dispose
end
end
Ahora podemos arrancar el juego y ver que hay una ventana y nuestra imagen, para sacar la ventana borramos @ventana = Window_Help.new y @ventana.dispose, ahora veremos nuestra imagen, pero se ve tan mal :( , no te preocupes, ahora veremos el zoom de la imagen.
Para saber cuanto zoom necesitamos ocuparemos una calculadora, si dividimos 544 en el tamaño de nuestra imagen en largo obtendremos nuestro zoom en x , o sea si mi imagen vale 1024, dividimos 544:1024 = 0,53125 , o sea que ese será mi zoom en x y asi hago lo mismo con Y , para que no utilizemos calculadora siempre haremos lo siguiente.
pondremos nuestra variable @misprite.zoom_x y la igualamos al total de la pantalla / total de nuestra imagen, donde total de nuestra imagen sera @misprite.bitmap.width .... y para el y sera 414 / @misprite.bitmap.height
De esta manera nuestra imagen se vera acorde al tamaño, si no queremos poner todo el tiempo 544 y 414 se puede poner mas facil usando Graphics.width.to_f para la horizontal y Graphics.height.to_f para la vertical.
El to_f es simplemente para indicar que Graphics es con decimales, para que no me lo deje en valores enteros o sino se nos ira a 0 si es muy grande el valor de la imagen.
Si queremos ver la opacidad de la imagen, hacemos la variable con extension .opacity, donde va la escala de 0 a 255 de nada a ver la imagen.
Si queremos ver o no la imagen se iguala a true para verla y false para sacarla
Eso es todo por ahora les dejo el script completo por si hay alguna duda, si tienen alguna otra pregunta me avisan y respondo:
class Scene_Mono < Scene_Base
#--------------------------------------------------------------------------
# ● Start
#--------------------------------------------------------------------------
def start
super()
@misprite = Sprite.new()
@misprite.bitmap = Cache.picture("IMG_20130818_184618")
@misprite.x = 0
@misprite.y = 0
@misprite.zoom_x = Graphics.width.to_f / @misprite.bitmap.width
@misprite.zoom_y = Graphics.height.to_f / @misprite.bitmap.height
end
#--------------------------------------------------------------------------
# ● Post_start
#--------------------------------------------------------------------------
def post_start
super()
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
super()
return_scene if Input.trigger?(:B)
end
#--------------------------------------------------------------------------
# ● Pre-terminate
#--------------------------------------------------------------------------
def pre_terminate
Sound.play_cancel
end
#--------------------------------------------------------------------------
# ● Terminate
#--------------------------------------------------------------------------
def terminate
super()
@misprite.dispose
@misprite.bitmap.dispose
end
end
#=============================================================================
# WINDOW
#=============================================================================
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
#=============================================================================
# SCENE
#=============================================================================
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
def command_Nuevo #~Que pasa si aprieto en la opcion
SceneManager.call(Scene_Mono)
end
end
#=============================================================================
Nos veremos en otra leccion, adios...
viernes, 16 de agosto de 2013
Lección 5: Dentro de una opción del menu
Empezaremos por editar el script de la leccion 4 y haremos que por lo menos podamos ver un texto dentro de esta opción, por mientras les dejo el video de diamondandplatinum3, para los demas seguiremos aca :))
Lo que haremos ahora es crear algo en la nueva opcion dentro del menu, por lo tanto al script de la leccion anterior, lo manejaremos denuevo y crearemos antes de él, una nueva clase, esta clase vendá heredada de la famosa scene_base, por lo que crearemos una, yo llamare a mi scene, Scene_Mono (recordar las mayus, que son importantes) y le heredare < Scene_Base.
Una vez hecho esto, en nuestro script ya hecho llamaremos a nuestra scene, en el metodo, que hablamos tanto en la leccion anterior, el mio era command_Nuevo. Le pondremos adentro esto SceneManager.call(nombre de la clase).
Luego de esto nos vamos al script Scene_Base, y copiaremos las partes importantes que deben tener las opciones, que son cuando empieza, lo que lleva, cuando se actualiza por cada frame, cuando esta a punto de terminar y por ultimo cuando termina, sin mucho mas atado, les pondre lo que tienen que copiar:
def start
create_main_viewport
end
#--------------------------------------------------------------------------
# ● 開始後処理
#--------------------------------------------------------------------------
def post_start
perform_transition
Input.update
end
#--------------------------------------------------------------------------
# ● シーン変更中判定
#--------------------------------------------------------------------------
def scene_changing?
SceneManager.scene != self
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
update_basic
end
#--------------------------------------------------------------------------
# ● フレーム更新（基本）
#--------------------------------------------------------------------------
def update_basic
Graphics.update
Input.update
update_all_windows
end
#--------------------------------------------------------------------------
# ● 終了前処理
#--------------------------------------------------------------------------
def pre_terminate
end
#--------------------------------------------------------------------------
# ● 終了処理
#--------------------------------------------------------------------------
def terminate
Graphics.freeze
dispose_all_windows
dispose_main_viewport
end
Borraremos cosas que no nos interesaran por ahora, que serian el metodo scene_changing? y el update_basic, y todas las cosas que tienen dentro de cada de metodo que nos queda pondremos un super(), si no saben para que, vean CB IV.
Una vez hecho esto, nos quedara asi:
#--------------------------------------------------------------------------
# ● 開始処理
#--------------------------------------------------------------------------
def start
super()
end
#--------------------------------------------------------------------------
# ● 開始後処理
#--------------------------------------------------------------------------
def post_start
super()
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
super()
end
#--------------------------------------------------------------------------
# ● 終了前処理
#--------------------------------------------------------------------------
def pre_terminate
end
#--------------------------------------------------------------------------
# ● 終了処理
#--------------------------------------------------------------------------
def terminate
super()
end
Y cuando tengamos esto, estaremos ya casi listos, pero si hacemos arrancar el juego nos dará probablemente un error o no hará nada.
Para esto es que debemos crear la ventana y para eso usaremos una variable de metodo, que yo llamare @ventana, esta variable la pondremos cuando arranca la opcion (start) y le asignaremos la ventana, Window_Help.new
Ahora si tendremos algo bueno, por lo menos veremos algo, pero no queda alli, ya que se quedará pegado y no podremos hacer algo más, es por esto que debemos, cuando se cierre la opcion (terminate), se cierre todo y volvamos a lo normal.
Primero colocaremos en terminate nuestra variable, con .dispose, que llamara a esta opcion (buscar .dispose para que quede mas claro) y por lo que dejara de usar la opcion, para que retorne adonde estabamos, o sea el menu nuevamente, debemos poner un return_scene, esto permitira devolvernos al menu.
Para esto pondremos return_scene, abajo del super() del metodo update.
Para que nos retorne al menu al apretar una tecla, pondremos al lado del return_scene esto,
if Input.trigger? (:B), esto significa que si el usuario aprieta B (del juego, en el teclado sera X, esc , etc)
nos devolvemos al menu original.
Bien eso es todo lo que haremos por ahora, aunque lo mas probable es que sigamos usando este script, asi que no lo borren, po mientras les dejo el script completo, al que le agregue una cosilla, que es para que cuando nos retornemos, haga el sonido de cancelar (linea 27), intenten averiguar el porque lo puse alli, aunque es mas que obvio.
class Scene_Mono < Scene_Base
#--------------------------------------------------------------------------
# ● Start
#--------------------------------------------------------------------------
def start
super()
@ventana = Window_Help.new
end
#--------------------------------------------------------------------------
# ● Post_start
#--------------------------------------------------------------------------
def post_start
super()
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
super()
return_scene if Input.trigger?(:B)
end
#--------------------------------------------------------------------------
# ● Pre-terminate
#--------------------------------------------------------------------------
def pre_terminate
Sound.play_cancel
end
#--------------------------------------------------------------------------
# ● Terminate
#--------------------------------------------------------------------------
def terminate
super()
@ventana.dispose
end
end
#=============================================================================
# WINDOW
#=============================================================================
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
#=============================================================================
# SCENE
#=============================================================================
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
def command_Nuevo #~Que pasa si aprieto en la opcion
SceneManager.call(Scene_Mono)
end
end
#=============================================================================
Eso es todo por ahora, nos veremos más adelante, para seguir aprendiendo...
miércoles, 14 de agosto de 2013
Leccion 4: Comandos de un Menú
Quien no quizo sacar del menu la opcion "save" jajaja, bueno, hoy aprenderemos a colocar y sacar comandos de la ventana de menú, puede que sea un poco complejo así que pongan atención, aparte les dejo el video explicativo en ingles de diamondandplatinum:
Antes de partir, les sugiero NO borrar este script, pues se utilizará mucho de aqui en adelante, comencemos
Lo que haremos es agregar un comando nuevo al menu de opciones del juego, para esto necesitamos llamar a la ventana que hace esto, que seria Scene_menu, si no damos cuenta, que en ese lado sale, skill, item, etc (de color anaranjado o algo asi), esto lo que hace es ponerle el nombre a la opcion y luego llamar al metodo, para que haga que se meta en la opcion. En nuestro nuevo script pondremos, class Scene_Menu < Scene_MenuBase , luego de esto, copiaremos justo ese metodo donde salen esas opciones, quedaria algo asi:
class Scene_menu < Scene_Menubase
def create_command_window
@command_window = Window_MenuCommand.new
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
end
Luego de esto, crearemos un alias, que hara que queden todas las funciones originales, para luego colocar la nuestra, esto quiere decir, que no modificaremos las originales, aca pueden usar cualquier nombre, yo le puse alias mono_scenemenu_ccw_nuevocomando y al lado el metodo.
Luego de esto, como siempre, borramos todo lo que tiene adentro y colocamos nuestro alias, sin el metodo al lado, Dejaremos o veremos si ya lo borraron, uno de los que tenia antes, para que nos sirva de ejemplo.
En el que dejamos, veremos que tiene las siguientes cosas:
@command_window.set_handler(:equip, method(:command_personal))
Donde :equip es el nombre de la opcion y method(:command_personal) es el metodo que llamará la opcion, entonces cambiaremos el nombre y le pondremos lo que queramos, yo le pondre Nuevo y el metodo, lo llamremos :command_Nuevo , si queremos saber porque es que lleva el nombre y el metodo, tendremos que buscar el porque dentro de los scripts, para esto apretamos, click derecho y buscamos "set_handler"
si nos damos cuenta, el primero que sale es una definicion del set_handler, y al lado sale (symbol, method), si pensamos bien es exactamente lo que estamos haciendo ahora, colocandole una palabra y luego un metodo, es solamente porque asi esta definido.
Una vez hecho esto buscaremos el que pondra nuestra opcion en el juego, para esto nos vamos a Window_MenuCommand y copiaremos y pegaremos en nuestro script la siguiente linea, que hace que se agreguen nuevos comandos:
def add_original_commands
end
Y tambien la clase heredada, o sea:
class Window_MenuCommand < Window_Command
Una vez pegado, le pondremos dentro de este metodo, esto de aca que se encuentra tambien en el window_menucommand:
add_command(Vocab::item, :item, main_commands_enabled)
Esto loq eu hace es agregar al menu nuestra opcion, con el nombre, lo que hace y si se puede seleccionar o no desde el menu.
entonces colocaremos un nombre que queramos, le pondre igual que el metodo "Nuevo" (entre comillas) y le colocaremos el nombre que llevaba la opcion :Nuevo , luego le colocaremos true, porque queremos seleccionarla, de otra manera si le ponemos false, no podremos entrar en ella.
Luego de esto, tendremos que ponerle un alias a nuestro comando, para no modificar el original, yo le pondre mono_windmenucomm_addorcomm_nuevopalabra, luego de esto le pondremos, dentro del metodo, pero sin borrar lo que hicimos, quedaria algo asi hasta ahora
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
end
Por último nos queda es colocar, que hacer cuando se selecciona la opcion, ya que si hasta ahora nos metemos en el juego, nos tirara error, porque no esta definido el metodo :command_Nuevo, es por esto, que lo haremos debajo de este, pondremos un def con el nombre del metodo llamado en el set_handler, y lo cerraremos, de esta manera
def command_Nuevo
end
Ahora si nuestra opcion esta lista para ser seleccionada, aunque no hará absolutamente nada jajaja, porque no hay nada dentro de ella, pero no se preocupen, porque este script no queda, hasta alli, luego haremos que haga por lo menos algo.
Por ahora les dejare el script completo y ordenado, para que se ubiquen y con algunas reseñas para que entiendan como va:
#=============================================================================
# WINDOW
#=============================================================================
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
#=============================================================================
# SCENE
#=============================================================================
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
def command_Nuevo #~Que pasa si aprieto en la opcion
end
end
#=============================================================================
Bueno es todo por ahora, nos veremos mas adelante, para seguir arreglando este script y se viene cada vez mas pesado, asi que recuerden como hacer cada cosa... por ahora les digo...
Antes de partir, les sugiero NO borrar este script, pues se utilizará mucho de aqui en adelante, comencemos
Lo que haremos es agregar un comando nuevo al menu de opciones del juego, para esto necesitamos llamar a la ventana que hace esto, que seria Scene_menu, si no damos cuenta, que en ese lado sale, skill, item, etc (de color anaranjado o algo asi), esto lo que hace es ponerle el nombre a la opcion y luego llamar al metodo, para que haga que se meta en la opcion. En nuestro nuevo script pondremos, class Scene_Menu < Scene_MenuBase , luego de esto, copiaremos justo ese metodo donde salen esas opciones, quedaria algo asi:
class Scene_menu < Scene_Menubase
def create_command_window
@command_window = Window_MenuCommand.new
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
end
Luego de esto, crearemos un alias, que hara que queden todas las funciones originales, para luego colocar la nuestra, esto quiere decir, que no modificaremos las originales, aca pueden usar cualquier nombre, yo le puse alias mono_scenemenu_ccw_nuevocomando y al lado el metodo.
Luego de esto, como siempre, borramos todo lo que tiene adentro y colocamos nuestro alias, sin el metodo al lado, Dejaremos o veremos si ya lo borraron, uno de los que tenia antes, para que nos sirva de ejemplo.
En el que dejamos, veremos que tiene las siguientes cosas:
@command_window.set_handler(:equip, method(:command_personal))
Donde :equip es el nombre de la opcion y method(:command_personal) es el metodo que llamará la opcion, entonces cambiaremos el nombre y le pondremos lo que queramos, yo le pondre Nuevo y el metodo, lo llamremos :command_Nuevo , si queremos saber porque es que lleva el nombre y el metodo, tendremos que buscar el porque dentro de los scripts, para esto apretamos, click derecho y buscamos "set_handler"
si nos damos cuenta, el primero que sale es una definicion del set_handler, y al lado sale (symbol, method), si pensamos bien es exactamente lo que estamos haciendo ahora, colocandole una palabra y luego un metodo, es solamente porque asi esta definido.
Una vez hecho esto buscaremos el que pondra nuestra opcion en el juego, para esto nos vamos a Window_MenuCommand y copiaremos y pegaremos en nuestro script la siguiente linea, que hace que se agreguen nuevos comandos:
def add_original_commands
end
Y tambien la clase heredada, o sea:
class Window_MenuCommand < Window_Command
Una vez pegado, le pondremos dentro de este metodo, esto de aca que se encuentra tambien en el window_menucommand:
add_command(Vocab::item, :item, main_commands_enabled)
Esto loq eu hace es agregar al menu nuestra opcion, con el nombre, lo que hace y si se puede seleccionar o no desde el menu.
entonces colocaremos un nombre que queramos, le pondre igual que el metodo "Nuevo" (entre comillas) y le colocaremos el nombre que llevaba la opcion :Nuevo , luego le colocaremos true, porque queremos seleccionarla, de otra manera si le ponemos false, no podremos entrar en ella.
Luego de esto, tendremos que ponerle un alias a nuestro comando, para no modificar el original, yo le pondre mono_windmenucomm_addorcomm_nuevopalabra, luego de esto le pondremos, dentro del metodo, pero sin borrar lo que hicimos, quedaria algo asi hasta ahora
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
end
Por último nos queda es colocar, que hacer cuando se selecciona la opcion, ya que si hasta ahora nos metemos en el juego, nos tirara error, porque no esta definido el metodo :command_Nuevo, es por esto, que lo haremos debajo de este, pondremos un def con el nombre del metodo llamado en el set_handler, y lo cerraremos, de esta manera
def command_Nuevo
end
Ahora si nuestra opcion esta lista para ser seleccionada, aunque no hará absolutamente nada jajaja, porque no hay nada dentro de ella, pero no se preocupen, porque este script no queda, hasta alli, luego haremos que haga por lo menos algo.
Por ahora les dejare el script completo y ordenado, para que se ubiquen y con algunas reseñas para que entiendan como va:
#=============================================================================
# WINDOW
#=============================================================================
class Window_MenuCommand < Window_Command
alias mono_windmenucomm_addorcomm_nuevopalabra add_original_commands
def add_original_commands
mono_windmenucomm_addorcomm_nuevopalabra
add_command("Nuevo", :Nuevo, true) # Crea solo la palabra el menu
end
end
#=============================================================================
# SCENE
#=============================================================================
class Scene_Menu < Scene_MenuBase
alias mono_scenemenu_ccw_nuevocomando create_command_window
def create_command_window
mono_scenemenu_ccw_nuevocomando
@command_window.set_handler(:Nuevo, method(:command_Nuevo))
end
def command_Nuevo #~Que pasa si aprieto en la opcion
end
end
#=============================================================================
Bueno es todo por ahora, nos veremos mas adelante, para seguir arreglando este script y se viene cada vez mas pesado, asi que recuerden como hacer cada cosa... por ahora les digo...
lunes, 12 de agosto de 2013
Conceptos básicos IX: Alias en un Module
Aprenderemos como editar los métodos de un modulo, sin modificar el original, pues por ejemplo, si queremos que siga la música en las batallas, necesitaremos editar el module de este...
Debemos recordar, que para colocar metodos dentro del module, se necesitaba colocar self.metodo (VER CB VIII), para poder usarlos. Ahora para poder modificarlos, dentro del mismo module, simplemente se coloca:
Class << self
Y con esto, nuestro module puede ser modificado, colocando un alias al igual en que se hace en el CB VI , para que quede mas claro, veamos el ejemplo siguiente:
module BattleManager
class << self
alias mono_battlemanager_bgmplay play_battle_bgm
def play_battle_bgm
unless $game_switches[1]
mono_battlemanager_bgmplay
end
end
end
end
Lo que hara este script es que si se activa el interruptor 1, entonces la musica del mapa no para al entrar en una batalla... como esto antes era un module, de battlemanager, ahora con el arreglo anterior, borramos todos los .self y lo dejamos como si fuera un metodo ordinario.
Debemos recordar, que para colocar metodos dentro del module, se necesitaba colocar self.metodo (VER CB VIII), para poder usarlos. Ahora para poder modificarlos, dentro del mismo module, simplemente se coloca:
Class << self
Y con esto, nuestro module puede ser modificado, colocando un alias al igual en que se hace en el CB VI , para que quede mas claro, veamos el ejemplo siguiente:
module BattleManager
class << self
alias mono_battlemanager_bgmplay play_battle_bgm
def play_battle_bgm
unless $game_switches[1]
mono_battlemanager_bgmplay
end
end
end
end
Lo que hara este script es que si se activa el interruptor 1, entonces la musica del mapa no para al entrar en una batalla... como esto antes era un module, de battlemanager, ahora con el arreglo anterior, borramos todos los .self y lo dejamos como si fuera un metodo ordinario.
domingo, 11 de agosto de 2013
Lección 3: Script de sonido de globos
Buenas a todos los que estan leyendo, hoy les traigo un poco más claro como usar las cosas y palabras claves, con un script hecho por Diamondandplatinum (abajo el video en ingles), gracias a él es que estamos aprendiendo de ruby, espero que sigamos porque se viene cada vez mejor
Como comentario les digo que cada vez se me hace más fácil (espero tambien a ustedes) intentar hacer los scripts que él hace de ejemplos, y espero que sigamos así.... Vamos mas o menos en la mitad del conocimiento, ya llevamos muchos conceptos aprendidos y seguiremos porque esto no para
Sin nada más que decir nos meteremos de fondo a este script, que es bastante sencillo. Pienso yo que lo más dificil es buscar el script correcto para poder editarlo y agregarle cosas, pero para saber bien es simple, porque el script que haremos es editar los globos animados del maker, tal que para que cuando salga un zzz suene un ruido asi de sueño (o el que quieran), sin estar haciendolo con engines (que chevere XD )
Para encontrar el script correcto, apretaremos buscar (click derecho sobre los script) y buscaremos "balloon", apretamos y buscaremos el que necesitamos, pero que rayos si hay muchos... no se preocupen piensen un poco con logica, los globos donde salen, en la cabeza de cada personaje, es por esto que debe ser alguno que dice sprite_character, asi que lo demas quedan fuera... ahora bien, siguen quedando muchos, pues aun mas, necesitamos que cuando aparezca el globo salga el sonido, entonces buscaremos alguno que diga "start" .... ooooh casualmente hay uno que dice def start balloon.... BINGO! ese es el sector que estamos buscando para editar...
Una vez que tenemos esto, copiamos la clase y el metodo que buscamos (def start_balloon) y lo pegamos ambos en un script.
Como ya tenemos lo necesario y editaremos lo que ya tenemos, tenemos que generar un alias , este alias puede ser como ya lo vimos como una quiera (el mio seria mono_sonidoburbuja_spritecharacter_startballoon) luego el metodo al lado del alias y listo
Una vez hecho esto, borramos lo que tiene dentro el metodo y ponemos nuestro alias sin el metodo al lado (si no sabes como, ver la leccion 2), una vez hecho esto, lo demás es un poco mas fácil.
Como queremos que ponga un sonido para cada globo, estos datos serán constantes y como ya vimos en conceptos anteriores, para hacer cosas constantes utilizaremos un module , este module tendra todos los sonidos para todos los globos... entonces haremos el module antes de la class y le pondremos el nombre que queramos (recuerden la inicial mayuscula), luego de esto, pondremos una variable local con el nombre, Sonido_globo1, o como quieran llamarle y le pondremos el sonido, asi como:
Sonido_esclamacion = ["Heal1",100,100]
y luego al otro globo, etc, etc. hasta tener los 10, sería asi mas o menos:
module Balloon_sounds
Sonido_esclamacion = ["Heal1",100,100]
Sonido_pregunta = ["Heal2",100,200]
Sonido_musical = ["Heal3",100,200]
Sonido_corazon = ["Attack1",100,200]
Sonido_enojo = ["Attack2",100,200]
Sonido_sudor = ["Attack3",100,200]
Sonido_desgranado = ["Buzzer1",100,200]
Sonido_silencio = ["Ice1",100,200]
Sonido_bombilla = [ nil ,100,200]
Sonido_dormido = ["Ice3",100,200]
end
Luego de esto que ya tenemos nuestros sonidos, hay que ponerlos en la class, de que manera, pues, en el script de los globos para identificar cada uno, llama a una variable de clase llamada @balloon_id , entonces esta es la que dice que si es 1, tiene que salir de imagen el de la exclamacion, si es 2, el de la pregunta y asi...
Es por eso que dentro del metodo def start_balloon, pondremos un case, para cada numero del ID, entonces ponemos debajo del alias, el case @balloon_id y debajo , when 1 y debajo de este llamaremos al module, para ponerle la musica dentro de este, lo haremos como el anexo II , desde el juego, pero dentro del parentesis le pondremos un * y luego llamaremos al module, de esta manera:
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play
¿porque el * ?, primero porque es un array y como el array, tiene strings (palabras) y valores, para ejecutarlo nos tirara error sin el * , mayormente no podria explicar bien el *, si alguien lo sabe seria de gran ayuda, pero por el momento se que no se pueden ejecutar en un array a la vez los strings y valores en conjunto.
Luego que tenemos esto, lo repetiremos las diez veces, con cada caso:
case @balloon_id
when 1
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play
when 2
RPG::SE.new(*Balloon_sounds::Sonido_pregunta).play
when 3
RPG::SE.new(*Balloon_sounds::Sonido_musical).play
when 4
RPG::SE.new(*Balloon_sounds::Sonido_corazon).play
when 5
RPG::SE.new(*Balloon_sounds::Sonido_enojo).play
when 6
RPG::SE.new(*Balloon_sounds::Sonido_sudor).play
when 7
RPG::SE.new(*Balloon_sounds::Sonido_desgranado).play
when 8
RPG::SE.new(*Balloon_sounds::Sonido_silencio).play
when 9
RPG::SE.new(*Balloon_sounds::Sonido_bombilla).play
when 10
RPG::SE.new(*Balloon_sounds::Sonido_dormido).play
end
Luego de esto terminamos jajaja.... simple no? , pues no terminamos tal cual, porque siempre hay que ponerse en el caso, que hay personas bieeeeen especiales y que siempre pondran cosas que no deben por error o porque son muy inteligentes (ironico), en el caso que no le pongan sonido a algun globo, nos tirara a un error, porque no sabe leer los vacios el script
para esto pondremos un if a cada uno de los casos para que se ejecute si no hay nada,, entonces al lado de cada RPG:: bla bla bla, le pondremos esto de aca:
if Balloon_sounds::Sonido_esclamacion[0]
y con eso estaria arreglado el problema :))
Lo último que euda y es una opcion, es para que el usuario que lo ocupe, pueda desactivar el script en caso de no quererlo, puede ser inmediato en el script o a traves de variables del juego
Si queremos que se desactive en el script, ponemos una Switch = true y dentro del modulo, ponemos if Balloon_sounds::Switch == true en el metodo y listo
Si queremos que sea mediante interruptores del juego, ponemos en el modulo Switch = 99 (o el que quieran) y luego en el metodo ponemos, $game.switches[numero del interruptor] y listo, pero recuerden hacer un evento en donde el numero del interruptor este activo o sino no funcionara ;)
Les dejo el script completo por si les salta alguna duda:
#-------------------------------------------------------------------------------
#----------------------- MODULE ----------------------------------------
#-------------------------------------------------------------------------------
module Balloon_sounds
# si se quiere activar (true) o no (false) los sonidos
Activacion = true
# aqui se cambian los sonidos para cada globo de animacion:
Sonido_esclamacion = ["Heal1",100,100]
Sonido_pregunta = ["Heal2",100,200]
Sonido_musical = ["Heal3",100,200]
Sonido_corazon = ["Attack1",100,200]
Sonido_enojo = ["Attack2",100,200]
Sonido_sudor = ["Attack3",100,200]
Sonido_desgranado = ["Buzzer1",100,200]
Sonido_silencio = ["Ice1",100,200]
Sonido_bombilla = [ nil ,100,200]
Sonido_dormido = ["Ice3",100,200]
end
#-------------------------------------------------------------------------------
#----------------------- SCRIPT ----------------------------------------
#-------------------------------------------------------------------------------
class Sprite_Character < Sprite_Base
#----------------------- ALIAS ----------------------------------------
alias mono_sonidoburbuja_spritecharacter_startballoon start_balloon
def start_balloon
#----------------------- SONIDOS ----------------------------------
if Balloon_sounds::Activacion
mono_sonidoburbuja_spritecharacter_startballoon()
case @balloon_id
when 1
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play if Balloon_sounds::Sonido_esclamacion[0]
when 2
RPG::SE.new(*Balloon_sounds::Sonido_pregunta).play if Balloon_sounds::Sonido_esclamacion[0]
when 3
RPG::SE.new(*Balloon_sounds::Sonido_musical).play if Balloon_sounds::Sonido_esclamacion[0]
when 4
RPG::SE.new(*Balloon_sounds::Sonido_corazon).play if Balloon_sounds::Sonido_esclamacion[0]
when 5
RPG::SE.new(*Balloon_sounds::Sonido_enojo).play if Balloon_sounds::Sonido_esclamacion[0]
when 6
RPG::SE.new(*Balloon_sounds::Sonido_sudor).play if Balloon_sounds::Sonido_esclamacion[0]
when 7
RPG::SE.new(*Balloon_sounds::Sonido_desgranado).play if Balloon_sounds::Sonido_esclamacion[0]
when 8
RPG::SE.new(*Balloon_sounds::Sonido_silencio).play if Balloon_sounds::Sonido_esclamacion[0]
when 9
RPG::SE.new(*Balloon_sounds::Sonido_bombilla).play if Balloon_sounds::Sonido_esclamacion[0]
when 10
RPG::SE.new(*Balloon_sounds::Sonido_dormido).play if Balloon_sounds::Sonido_esclamacion[0]
end
end
end
end
Eso es todo por ahora, espero le haya gustado y nos veremos en otro tutorial, recuerden que cualquier duda, pregunten y no se queden con la duda :)), por ahora solo queda decir...
Como comentario les digo que cada vez se me hace más fácil (espero tambien a ustedes) intentar hacer los scripts que él hace de ejemplos, y espero que sigamos así.... Vamos mas o menos en la mitad del conocimiento, ya llevamos muchos conceptos aprendidos y seguiremos porque esto no para
Sin nada más que decir nos meteremos de fondo a este script, que es bastante sencillo. Pienso yo que lo más dificil es buscar el script correcto para poder editarlo y agregarle cosas, pero para saber bien es simple, porque el script que haremos es editar los globos animados del maker, tal que para que cuando salga un zzz suene un ruido asi de sueño (o el que quieran), sin estar haciendolo con engines (que chevere XD )
Para encontrar el script correcto, apretaremos buscar (click derecho sobre los script) y buscaremos "balloon", apretamos y buscaremos el que necesitamos, pero que rayos si hay muchos... no se preocupen piensen un poco con logica, los globos donde salen, en la cabeza de cada personaje, es por esto que debe ser alguno que dice sprite_character, asi que lo demas quedan fuera... ahora bien, siguen quedando muchos, pues aun mas, necesitamos que cuando aparezca el globo salga el sonido, entonces buscaremos alguno que diga "start" .... ooooh casualmente hay uno que dice def start balloon.... BINGO! ese es el sector que estamos buscando para editar...
Una vez que tenemos esto, copiamos la clase y el metodo que buscamos (def start_balloon) y lo pegamos ambos en un script.
Como ya tenemos lo necesario y editaremos lo que ya tenemos, tenemos que generar un alias , este alias puede ser como ya lo vimos como una quiera (el mio seria mono_sonidoburbuja_spritecharacter_startballoon) luego el metodo al lado del alias y listo
Una vez hecho esto, borramos lo que tiene dentro el metodo y ponemos nuestro alias sin el metodo al lado (si no sabes como, ver la leccion 2), una vez hecho esto, lo demás es un poco mas fácil.
Como queremos que ponga un sonido para cada globo, estos datos serán constantes y como ya vimos en conceptos anteriores, para hacer cosas constantes utilizaremos un module , este module tendra todos los sonidos para todos los globos... entonces haremos el module antes de la class y le pondremos el nombre que queramos (recuerden la inicial mayuscula), luego de esto, pondremos una variable local con el nombre, Sonido_globo1, o como quieran llamarle y le pondremos el sonido, asi como:
Sonido_esclamacion = ["Heal1",100,100]
y luego al otro globo, etc, etc. hasta tener los 10, sería asi mas o menos:
module Balloon_sounds
Sonido_esclamacion = ["Heal1",100,100]
Sonido_pregunta = ["Heal2",100,200]
Sonido_musical = ["Heal3",100,200]
Sonido_corazon = ["Attack1",100,200]
Sonido_enojo = ["Attack2",100,200]
Sonido_sudor = ["Attack3",100,200]
Sonido_desgranado = ["Buzzer1",100,200]
Sonido_silencio = ["Ice1",100,200]
Sonido_bombilla = [ nil ,100,200]
Sonido_dormido = ["Ice3",100,200]
end
Luego de esto que ya tenemos nuestros sonidos, hay que ponerlos en la class, de que manera, pues, en el script de los globos para identificar cada uno, llama a una variable de clase llamada @balloon_id , entonces esta es la que dice que si es 1, tiene que salir de imagen el de la exclamacion, si es 2, el de la pregunta y asi...
Es por eso que dentro del metodo def start_balloon, pondremos un case, para cada numero del ID, entonces ponemos debajo del alias, el case @balloon_id y debajo , when 1 y debajo de este llamaremos al module, para ponerle la musica dentro de este, lo haremos como el anexo II , desde el juego, pero dentro del parentesis le pondremos un * y luego llamaremos al module, de esta manera:
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play
¿porque el * ?, primero porque es un array y como el array, tiene strings (palabras) y valores, para ejecutarlo nos tirara error sin el * , mayormente no podria explicar bien el *, si alguien lo sabe seria de gran ayuda, pero por el momento se que no se pueden ejecutar en un array a la vez los strings y valores en conjunto.
Luego que tenemos esto, lo repetiremos las diez veces, con cada caso:
case @balloon_id
when 1
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play
when 2
RPG::SE.new(*Balloon_sounds::Sonido_pregunta).play
when 3
RPG::SE.new(*Balloon_sounds::Sonido_musical).play
when 4
RPG::SE.new(*Balloon_sounds::Sonido_corazon).play
when 5
RPG::SE.new(*Balloon_sounds::Sonido_enojo).play
when 6
RPG::SE.new(*Balloon_sounds::Sonido_sudor).play
when 7
RPG::SE.new(*Balloon_sounds::Sonido_desgranado).play
when 8
RPG::SE.new(*Balloon_sounds::Sonido_silencio).play
when 9
RPG::SE.new(*Balloon_sounds::Sonido_bombilla).play
when 10
RPG::SE.new(*Balloon_sounds::Sonido_dormido).play
end
Luego de esto terminamos jajaja.... simple no? , pues no terminamos tal cual, porque siempre hay que ponerse en el caso, que hay personas bieeeeen especiales y que siempre pondran cosas que no deben por error o porque son muy inteligentes (ironico), en el caso que no le pongan sonido a algun globo, nos tirara a un error, porque no sabe leer los vacios el script
para esto pondremos un if a cada uno de los casos para que se ejecute si no hay nada,, entonces al lado de cada RPG:: bla bla bla, le pondremos esto de aca:
if Balloon_sounds::Sonido_esclamacion[0]
y con eso estaria arreglado el problema :))
Lo último que euda y es una opcion, es para que el usuario que lo ocupe, pueda desactivar el script en caso de no quererlo, puede ser inmediato en el script o a traves de variables del juego
Si queremos que se desactive en el script, ponemos una Switch = true y dentro del modulo, ponemos if Balloon_sounds::Switch == true en el metodo y listo
Si queremos que sea mediante interruptores del juego, ponemos en el modulo Switch = 99 (o el que quieran) y luego en el metodo ponemos, $game.switches[numero del interruptor] y listo, pero recuerden hacer un evento en donde el numero del interruptor este activo o sino no funcionara ;)
Les dejo el script completo por si les salta alguna duda:
#-------------------------------------------------------------------------------
#----------------------- MODULE ----------------------------------------
#-------------------------------------------------------------------------------
module Balloon_sounds
# si se quiere activar (true) o no (false) los sonidos
Activacion = true
# aqui se cambian los sonidos para cada globo de animacion:
Sonido_esclamacion = ["Heal1",100,100]
Sonido_pregunta = ["Heal2",100,200]
Sonido_musical = ["Heal3",100,200]
Sonido_corazon = ["Attack1",100,200]
Sonido_enojo = ["Attack2",100,200]
Sonido_sudor = ["Attack3",100,200]
Sonido_desgranado = ["Buzzer1",100,200]
Sonido_silencio = ["Ice1",100,200]
Sonido_bombilla = [ nil ,100,200]
Sonido_dormido = ["Ice3",100,200]
end
#-------------------------------------------------------------------------------
#----------------------- SCRIPT ----------------------------------------
#-------------------------------------------------------------------------------
class Sprite_Character < Sprite_Base
#----------------------- ALIAS ----------------------------------------
alias mono_sonidoburbuja_spritecharacter_startballoon start_balloon
def start_balloon
#----------------------- SONIDOS ----------------------------------
if Balloon_sounds::Activacion
mono_sonidoburbuja_spritecharacter_startballoon()
case @balloon_id
when 1
RPG::SE.new(*Balloon_sounds::Sonido_esclamacion).play if Balloon_sounds::Sonido_esclamacion[0]
when 2
RPG::SE.new(*Balloon_sounds::Sonido_pregunta).play if Balloon_sounds::Sonido_esclamacion[0]
when 3
RPG::SE.new(*Balloon_sounds::Sonido_musical).play if Balloon_sounds::Sonido_esclamacion[0]
when 4
RPG::SE.new(*Balloon_sounds::Sonido_corazon).play if Balloon_sounds::Sonido_esclamacion[0]
when 5
RPG::SE.new(*Balloon_sounds::Sonido_enojo).play if Balloon_sounds::Sonido_esclamacion[0]
when 6
RPG::SE.new(*Balloon_sounds::Sonido_sudor).play if Balloon_sounds::Sonido_esclamacion[0]
when 7
RPG::SE.new(*Balloon_sounds::Sonido_desgranado).play if Balloon_sounds::Sonido_esclamacion[0]
when 8
RPG::SE.new(*Balloon_sounds::Sonido_silencio).play if Balloon_sounds::Sonido_esclamacion[0]
when 9
RPG::SE.new(*Balloon_sounds::Sonido_bombilla).play if Balloon_sounds::Sonido_esclamacion[0]
when 10
RPG::SE.new(*Balloon_sounds::Sonido_dormido).play if Balloon_sounds::Sonido_esclamacion[0]
end
end
end
end
Eso es todo por ahora, espero le haya gustado y nos veremos en otro tutorial, recuerden que cualquier duda, pregunten y no se queden con la duda :)), por ahora solo queda decir...
viernes, 9 de agosto de 2013
Conceptos Básicos VIII : Module y is_a?
Aprenderemos 2 conceptos bastantes interesantes, el module y el condicional is_a? , que son un poco extras en los scripts que ya estan en el maker, pero necesarios para que nosotros podamos hacer uno.
---------------------------------- MODULE -------------------------------------------
Para los que saben programar, el module es como una estructura, permite almacenar datos constantes y tambien poner métodos dentro de él, hay que entender y es muy importante, es que los modulos siempre estan activados, sea cual sea su posicion en los scripts.
para entender bien como usar un module loa veremos con un ejemplo:
module Hola
Boolean = true
Numero = 45
end
def nombre()
msgbox("anita lava la tina :DD ") if Hola::Boolean == true
msgbox("numero por aca :)) ") if Hola::Numero != 0
nombre()
basicamente se crea el modulo como aparece y siempre deben ir con mayusculas las iniciales... para llamarlos desde algun metodo se pone con el nombre del modulo, 2 dos puntos, y luego la constante.
Para llamar metodos del modulos desde otros metodos, simplemente se escribe el modulo que se busca, punto, y luego el metodo dentro del modulo, ejemplo:
module Llamando
def self.Script_one
msgbox("lol")
end
end
def Llamar()
Llamando.Script_one
end
Llamar()
olvide algo importanticimo, que es que todos lo metodos dentro del modulo DEBEN llevar " self. " antes del nombre del metodo, o sino tirará error
--------------------------------- CONDICIONAL IS_A? ------------------------------
El condicional is_a?, verifica si lo que tiene a su lado izquierdo es igual a lo que se encuentra entre parentesis
por ejemplo:
module Llamando
Numero = 13
Letra = "a"
Decimal= 3.14
def self.Script_one
msgbox("lol")
end
end
def Llamar()
msgbox("numero") if Llamando::Numero.is_a?(Integer) # integer = entero
msgbox("letra") if Llamando::Letra.is_a?(String) # String = letras
msgbox("decimal") if Llamando::Decimal.is_a?(Float) # Float = decimal
Llamando.Script_one
end
Llamar()
siempre lo que se va a comparar lleva .is_a?(integer/float/string/variable/etc)
---------------------------------- MODULE -------------------------------------------
Para los que saben programar, el module es como una estructura, permite almacenar datos constantes y tambien poner métodos dentro de él, hay que entender y es muy importante, es que los modulos siempre estan activados, sea cual sea su posicion en los scripts.
para entender bien como usar un module loa veremos con un ejemplo:
module Hola
Boolean = true
Numero = 45
end
def nombre()
msgbox("anita lava la tina :DD ") if Hola::Boolean == true
msgbox("numero por aca :)) ") if Hola::Numero != 0
nombre()
basicamente se crea el modulo como aparece y siempre deben ir con mayusculas las iniciales... para llamarlos desde algun metodo se pone con el nombre del modulo, 2 dos puntos, y luego la constante.
Para llamar metodos del modulos desde otros metodos, simplemente se escribe el modulo que se busca, punto, y luego el metodo dentro del modulo, ejemplo:
module Llamando
def self.Script_one
msgbox("lol")
end
end
def Llamar()
Llamando.Script_one
end
Llamar()
olvide algo importanticimo, que es que todos lo metodos dentro del modulo DEBEN llevar " self. " antes del nombre del metodo, o sino tirará error
--------------------------------- CONDICIONAL IS_A? ------------------------------
El condicional is_a?, verifica si lo que tiene a su lado izquierdo es igual a lo que se encuentra entre parentesis
por ejemplo:
module Llamando
Numero = 13
Letra = "a"
Decimal= 3.14
def self.Script_one
msgbox("lol")
end
end
def Llamar()
msgbox("numero") if Llamando::Numero.is_a?(Integer) # integer = entero
msgbox("letra") if Llamando::Letra.is_a?(String) # String = letras
msgbox("decimal") if Llamando::Decimal.is_a?(Float) # Float = decimal
Llamando.Script_one
end
Llamar()
siempre lo que se va a comparar lleva .is_a?(integer/float/string/variable/etc)
miércoles, 7 de agosto de 2013
Conceptos básicos VII : Bucles
Hoy veremos lo que son los bucles, un bucle es una repetición continua de algún valor y que lleva alguna sentencia para que esta termine, aprenderemos: while , for , do, .each, .times y el break, que no es un bucle, sino que es el que corta los bucles a media...
----------------------------------- WHILE ------------------------------------------
El while es una repetición de cosas hasta que se cumpla una sentencia, por ejemplo:
def while_m
local = 0
while (local <= 10)
print local
local += 1
end
end
while_m
se imprimirá cada numero del 0 al 10 hasta que local sea 10, después de esto se termina y no imprimirá más numeros
def while_m
local = 0
while (local < 10)
print local
local += 1
end
end
while_m
Se imprimirá cada numero del 0 al 9, debido a que, cuando sea local = 10, no correra el print
-------------------------------- FOR ------------------------------------------------------
El for no usa una sentencia directa para usarlo,sino que se detalla, se puede hacer de esta manera
def for_m
local = [0, 23, "holo", 4.76 , false]
for cantidad in local
print cantidad
end
end
for_m
---------------------------- DO & .EACH ---------------------------------------------------------
Este método es más utilizado, por ejemplo si tenemos un array o matriz o arreglo (como quieran llamarle)
como el anterior ejemplo, podemos nombrar cada uno de la siguiente manera:
def do_each_m
local = [0, 23, "holo", 4.76 , false]
local.each do |cantidad|
print cantidad
end
end
do_each_m
esto significa: "para cada (each) valor (cantidad) que esta en la variable (local), hacer (do): " , es simplemente eso y debajo de él, va lo que se quiera hacer, esta claro que cantidad es una variable, porque cambia a cada rato, y no es necesario definir a cuanto equivale...
La manera más tradicional de usar en los scripts es acortar todo lo que hace local en una sola linea, haciéndolo de esta manera:
def each_m
local = [0, 23, "holo", 4.76 , false]
local.each{ |cantidad| print cantidad }
end
each_m
de esta manera se hace, colocando todo en una linea, vale decir que el do y el end desparecen y se coloca entre llaves lo que se quiere hacer
-------------------------- .TIMES -------------------------------------------------------------
Este método es igual al anterior pero con un valor antes de hacer lo que se quiera, por ejemplo:
def times_m
local = "holo"
100.times {print local}
end
times_m
---------------------------- BREAK --------------------------------------------------------
El break se usa para cortar la repeticion, se puede usar con el condicional if, veremos cada caso con
un break:
def while_m
local = 0
while (local <= 10)
print local
break if local == 7
local += 1
end
end
while_m
----------------------------------- WHILE ------------------------------------------
El while es una repetición de cosas hasta que se cumpla una sentencia, por ejemplo:
def while_m
local = 0
while (local <= 10)
print local
local += 1
end
end
while_m
se imprimirá cada numero del 0 al 10 hasta que local sea 10, después de esto se termina y no imprimirá más numeros
def while_m
local = 0
while (local < 10)
print local
local += 1
end
end
while_m
Se imprimirá cada numero del 0 al 9, debido a que, cuando sea local = 10, no correra el print
-------------------------------- FOR ------------------------------------------------------
El for no usa una sentencia directa para usarlo,sino que se detalla, se puede hacer de esta manera
def for_m
local = [0, 23, "holo", 4.76 , false]
for cantidad in local
print cantidad
end
end
for_m
---------------------------- DO & .EACH ---------------------------------------------------------
Este método es más utilizado, por ejemplo si tenemos un array o matriz o arreglo (como quieran llamarle)
como el anterior ejemplo, podemos nombrar cada uno de la siguiente manera:
def do_each_m
local = [0, 23, "holo", 4.76 , false]
local.each do |cantidad|
print cantidad
end
end
do_each_m
esto significa: "para cada (each) valor (cantidad) que esta en la variable (local), hacer (do): " , es simplemente eso y debajo de él, va lo que se quiera hacer, esta claro que cantidad es una variable, porque cambia a cada rato, y no es necesario definir a cuanto equivale...
La manera más tradicional de usar en los scripts es acortar todo lo que hace local en una sola linea, haciéndolo de esta manera:
def each_m
local = [0, 23, "holo", 4.76 , false]
local.each{ |cantidad| print cantidad }
end
each_m
de esta manera se hace, colocando todo en una linea, vale decir que el do y el end desparecen y se coloca entre llaves lo que se quiere hacer
-------------------------- .TIMES -------------------------------------------------------------
Este método es igual al anterior pero con un valor antes de hacer lo que se quiera, por ejemplo:
def times_m
local = "holo"
100.times {print local}
end
times_m
---------------------------- BREAK --------------------------------------------------------
El break se usa para cortar la repeticion, se puede usar con el condicional if, veremos cada caso con
un break:
- En el ejemplo 1 si queremos que llegue solo hasta 7 y luego terminar
def while_m
local = 0
while (local <= 10)
print local
break if local == 7
local += 1
end
end
while_m
- En el ejemplo 2 si queremos que llegue antes del "holo":
def for_m
local = [0, 23, "holo", 4.76 , false]
for cantidad in local
break if cantidad == "holo"
print cantidad
end
end
for_m
- En el ejemplo 3 si queremos que se corte en 4.76:
def do_each_m
local = [0, 23, "holo", 4.76 , false]
local.each do |cantidad|
print cantidad
break if cantidad == 4.76
end
end
do_each_m
local = [0, 23, "holo", 4.76 , false]
local.each do |cantidad|
print cantidad
break if cantidad == 4.76
end
end
do_each_m
- En el ejemplo 4 si queremos que llegue hasta de 65
def times_m
local = 1
100.times {
break if local > 65
print local
local +=1
}
end
times_m
martes, 6 de agosto de 2013
Anexo II: llamado de los sonidos
Como llamar a las canciones a los sonidos del maker en algún script?, pues asi
desde la pantalla de window:
Audio.bgm_play("Audio/BGM/Battle1", 100, 100)
Audio.bgs_play("Audio/BGS/Fire", 80, 100)
Audio.me_play("Audio/ME/Victory1", 80, 100)
Audio.se_play("Audio/SE/Absorb1", 100, 100)
en general: lo que hace es meterse en la carpeta donde se ubica el maker. es por eso que se pone Audio seguido de los " / ", pues estamos buscando la direccion donde se encuentra cada uno de los sonidos. seguido del volumen (0 a 100) y luego la frecuencia (entre 5 y 200)
desde el juego:
RPG::BGM.new("Battle1",100,100).play
RPG::BGS.new("River",100,100).play
RPG::ME.new("Shock",100,100).play
RPG::SE.new("Fire1",100,100).play
en general: lo que hace es generar la musica que esta en la data base del juego, para luego reproducirla, si la musica no se encuentra en el maker, tirará error; seguido del volumen (0 a 100) y luego la frecuencia (entre 5 y 200) y luego .play
desde la pantalla de window:
Audio.bgm_play("Audio/BGM/Battle1", 100, 100)
Audio.bgs_play("Audio/BGS/Fire", 80, 100)
Audio.me_play("Audio/ME/Victory1", 80, 100)
Audio.se_play("Audio/SE/Absorb1", 100, 100)
en general: lo que hace es meterse en la carpeta donde se ubica el maker. es por eso que se pone Audio seguido de los " / ", pues estamos buscando la direccion donde se encuentra cada uno de los sonidos. seguido del volumen (0 a 100) y luego la frecuencia (entre 5 y 200)
desde el juego:
RPG::BGM.new("Battle1",100,100).play
RPG::BGS.new("River",100,100).play
RPG::ME.new("Shock",100,100).play
RPG::SE.new("Fire1",100,100).play
en general: lo que hace es generar la musica que esta en la data base del juego, para luego reproducirla, si la musica no se encuentra en el maker, tirará error; seguido del volumen (0 a 100) y luego la frecuencia (entre 5 y 200) y luego .play
Leccion 2: Script de Cambio de sonido
Bienvenidos, estuve todo el rato haciendo conceptos basicos para hacer finalmente un script bastante facilito que parece complejo, no vamos a ver el video del usuario de siempre, sino de otra persona, podrán ver el video en ingles, y luego veremos como hacerlo, asi que finalmente, podremos ver algo para el juego que ya pueden implementar a su juego :)) ... un detalle es que por ahora esta explicado con el rgss3 que es del rmvx ace, despues se posteará el de vx... Comencemos
El script que se explicará aca es que cuando el personaje no pueda pasar por algun lado, haga algún sonido de colision, vamos por partes...
Primero crearemos un nuevo script en insertar, arriba de main, para saber como el personaje se detiene en el juego, tendremos que buscar en todos los script esa parte, para hacerlo mas facil haremos el buscar con la siquiente busqueda passable con esto nos saldrá la ventana de busqueda, como necesitamos saber como lo hace el personaje nos meteremos en la que dice Game_Characterbase (168)...
aca nos saldrá esto:
def passable?(x, y, d)
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return true if @through || debug_through?
return false unless map_passable?(x, y, d)
return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_characters?(x2, y2)
return true
end
Lo que hace esto es ver donde se ubica el personaje, que no se salga de los bordes y que no traspase las cosas que estan marcadas con la X cuando vemos los permisos en los tilesets... para eso copiaremos todo esto y lo pegaremos en nuestro nuevo script, antes del def copiaremos la class del Game_Player esta de aqui class Game_Player < Game_Character y la pegaremos encima... nos quedaria algo asi:
class Game_Player < Game_Character
def passable?(x, y, d)
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return true if @through || debug_through?
return false unless map_passable?(x, y, d)
return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_characters?(x2, y2)
return true
end
end
Bien, como queremos modificar este metodo para que haga el sonido, no podemos modificarlo, tal cual esta, debido a que si lo hacemos podrias producirse un error, debido a que este script depende de otros más y está todos unidos.... para eso utilizaremos un alias que nos ayudará a mantener el script original y agregaremos parte del nuevo.
Como se dijo antes utilizaremos un alias que queramos seguido del metodo puesto passable?, el mio será asi, mono_sonidocolision_gameplayer_passable passable?, como ya esta puesto, no será necesario lo que lleve puesto el metodo passable?, por lo tanto borraremos todo lo que tiene y pondremos nuestro alias sin el metodo que va despues del espacio, quedaría asi
class Game_Player < Game_Character
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
mono_sonidocolision_gameplayer_passable
end
end
Bien, ahora lo que haremos es que nuestro alias, que es el que lleva todo lo del script original, se guarde en una variable local, para que tenga todos los valores de si no podemos pasar, pasemos, etc... le pondremos a esta variable passable. Por lo que nos quedaria que passable = mono_sonidocolision_gameplayer_passable y como vemos que el metodo passable? necesita de tres variables x, y y d, nuestro alias tambien deberá llevarlos o sino nos dará error, por lo tanto la variable local passable quedará asi
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
Tenemos ya una idea de lo que puede pasar, como passable viene del ingles pasable, imaginemonos que pasaria si es verdad o sea que se puede pasar, y si es falso, o sea que no se puede pasar, para esto utilizaremos un if que nos maracara cuando hacer el sonido y cuando no lo hará.
Para este if pondremos nuestra variable passable seguido de lo que nos importa, que no se pueda pasar, o sea, false . Si passable == false, entonces reproduciremos un SE del juego, este puede ser cualquiera pero le pondremos el de "Bite", nos quedaría hasta el momento asi
class Game_Player < Game_Character
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false
RPG::SE.new("Bite", 80, 100).play
end
end
end
El script que se explicará aca es que cuando el personaje no pueda pasar por algun lado, haga algún sonido de colision, vamos por partes...
Primero crearemos un nuevo script en insertar, arriba de main, para saber como el personaje se detiene en el juego, tendremos que buscar en todos los script esa parte, para hacerlo mas facil haremos el buscar con la siquiente busqueda passable con esto nos saldrá la ventana de busqueda, como necesitamos saber como lo hace el personaje nos meteremos en la que dice Game_Characterbase (168)...
aca nos saldrá esto:
def passable?(x, y, d)
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return true if @through || debug_through?
return false unless map_passable?(x, y, d)
return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_characters?(x2, y2)
return true
end
Lo que hace esto es ver donde se ubica el personaje, que no se salga de los bordes y que no traspase las cosas que estan marcadas con la X cuando vemos los permisos en los tilesets... para eso copiaremos todo esto y lo pegaremos en nuestro nuevo script, antes del def copiaremos la class del Game_Player esta de aqui class Game_Player < Game_Character y la pegaremos encima... nos quedaria algo asi:
class Game_Player < Game_Character
def passable?(x, y, d)
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return true if @through || debug_through?
return false unless map_passable?(x, y, d)
return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_characters?(x2, y2)
return true
end
end
Bien, como queremos modificar este metodo para que haga el sonido, no podemos modificarlo, tal cual esta, debido a que si lo hacemos podrias producirse un error, debido a que este script depende de otros más y está todos unidos.... para eso utilizaremos un alias que nos ayudará a mantener el script original y agregaremos parte del nuevo.
Como se dijo antes utilizaremos un alias que queramos seguido del metodo puesto passable?, el mio será asi, mono_sonidocolision_gameplayer_passable passable?, como ya esta puesto, no será necesario lo que lleve puesto el metodo passable?, por lo tanto borraremos todo lo que tiene y pondremos nuestro alias sin el metodo que va despues del espacio, quedaría asi
class Game_Player < Game_Character
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
mono_sonidocolision_gameplayer_passable
end
end
Bien, ahora lo que haremos es que nuestro alias, que es el que lleva todo lo del script original, se guarde en una variable local, para que tenga todos los valores de si no podemos pasar, pasemos, etc... le pondremos a esta variable passable. Por lo que nos quedaria que passable = mono_sonidocolision_gameplayer_passable y como vemos que el metodo passable? necesita de tres variables x, y y d, nuestro alias tambien deberá llevarlos o sino nos dará error, por lo tanto la variable local passable quedará asi
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
Tenemos ya una idea de lo que puede pasar, como passable viene del ingles pasable, imaginemonos que pasaria si es verdad o sea que se puede pasar, y si es falso, o sea que no se puede pasar, para esto utilizaremos un if que nos maracara cuando hacer el sonido y cuando no lo hará.
Para este if pondremos nuestra variable passable seguido de lo que nos importa, que no se pueda pasar, o sea, false . Si passable == false, entonces reproduciremos un SE del juego, este puede ser cualquiera pero le pondremos el de "Bite", nos quedaría hasta el momento asi
class Game_Player < Game_Character
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false
RPG::SE.new("Bite", 80, 100).play
end
end
end
Lo de la musica lo veremos en el anexo...
Luego terminamos nuestro script, pero falta algo importantisimo, que como este metodo funciona si ocurre algo, si lo dejamos asi, no estará devolviendo un valor al script original, por lo que necesitaremos devolver lo que esta haciendo, para esto utilizaremos un return que hará que lo que hicimos se vaya al juego, por asi decirlo, por lo que luego del end del if, pondremos que retorne la variable local passable, de esta manera:
class Game_Player < Game_Character
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false
RPG::SE.new("Bite", 80, 100).play
end
return passable
end
end
Listo tenemos nuestro script, preparado para funcionar.... pruebalo y dime que tal...
¿Hay algo que no te gusta cierto?, pues debe ser a que el sonido se repite muchas veces y no cada cierto tiempo... para eso arreglaremos el script, para que cada cierto tiempo se reproduzca.... sigamos entonces
generaremos un timer... para eso buscaremos el initialize de la class Game_Player, que es este de aca:
def initialize
super
@vehicle_type = :walk
@vehicle_getting_on = false
@vehicle_getting_off = false
@followers = Game_Followers.new(self)
@transparent = $data_system.opt_transparent
clear_transfer_info
end
y lo pegaremos encima del alias que generamos, a este initialize tambien le haremos un alias y borraremos lo que lleve dentro... ¿porque pegamos un initialize?, porque el initialize es el "inicial" del script, alli van todos los datos antes de.., y para eso, usaremos el initialize para generar el timer que controla el tiempo de reproduccion del SE.
bueno con esta explicacion el script deberia quedar asi:
class Game_Player < Game_Character
#--------------------------------------------------------------------
#------------------------- INITIALIZE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_initialize initialize
def initialize
mono_sonidocolision_gameplayer_initialize
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false
RPG::SE.new("Bite", 80, 100).play
end
return passable
end
end
Generaremos el timer ahora.... para eso haremos una variable de metodo (@) y le pndremos
@timer_del_SE , a esta le asignaremos el valor 0 (@timer_del_SE = 0).
Luego en la parte del sonido colocaremos esta variable y le colocaremos igual a 60, ¿porque?, esperemos al todo para tener la idea, quedaria algo asi:
class Game_Player < Game_Character
#--------------------------------------------------------------------
#------------------------- INITIALIZE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_initialize initialize
def initialize
mono_sonidocolision_gameplayer_initialize
@timer_del_SE = 0
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false
RPG::SE.new("Bite", 80, 100).play
@timer_del_SE = 60
end
return passable
end
end
ahora que tenemos esto tenemos que asegurarnos de que el timer este en 0 para reproducir el sonido, ya que si no es 0, reproducira una y otra vez y otra vez y no que parta el sonido desde 0, entonces en el if le pondremos que passable == false && @timer_del_SE == 0, para que se escuche el sonido.
Bien ahora tenemos que el timer parte de 0, pero nunca volvera a 0 una vez que lo hagamos, porque no se borra solo, o sea de 0 pasa a 60, pero luego no vuelve a 0, sino que se queda en 60 todo el rato D:>
No se preocupen, ahora usaremos el metodo update, que se encargará de que le reste 1 al timer por cada frame del juego hasta que llegue a 0 nuevamente. Para esto buscaremos, nuevamente del script Game_Player , el metodo update, que es este de aca:
def update
last_real_x = @real_x
last_real_y = @real_y
last_moving = moving?
move_by_input
super
update_scroll(last_real_x, last_real_y)
update_vehicle
update_nonmoving(last_moving) unless moving?
@followers.update
end
y lo pegaremos despues del initalize... le pondremos un alias nuevamente y borramos lo que tiene adentro y llamaremos a nuestro alias, quedando algo asi:
class Game_Player < Game_Character
#--------------------------------------------------------------------
#------------------------- INITIALIZE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_initialize initialize
def initialize
mono_sonidocolision_gameplayer_initialize
@timer_del_SE = 0
end
#--------------------------------------------------------------------
#------------------------- UPDATE -----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_update update
def update
mono_sonidocolision_gameplayer_update
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE ----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false && @timer_del_SE == 0
RPG::SE.new("Bite", 80, 100).play
@timer_del_SE = 60
end
return passable
end
end
Luego que tenemos esto pondremos la variable de metodo y le restaremos 1 por cada frame , y luego de este un unless que le dira al programa que no siga restando si la variable ya es igual a 0, quedando asi:
@timer_del_SE -= 1 unless @timer_del_SE == 0
para que finalmente nuestro script quede de esta manera:
class Game_Player < Game_Character
#--------------------------------------------------------------------
#------------------------- INITIALIZE -------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_initialize initialize
def initialize
mono_sonidocolision_gameplayer_initialize
@timer_del_SE = 0
end
#--------------------------------------------------------------------
#------------------------- UPDATE -----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_update update
def update
mono_sonidocolision_gameplayer_update
@timer_del_SE -= 1 unless @timer_del_SE == 0
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE ----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false && @timer_del_SE == 0
RPG::SE.new("Bite", 80, 100).play
@timer_del_SE = 60
end
return passable
end
end
VENGA QUE HAY QUE PROBAR EL SCRIPT!!! CHAN CHAN CHAN :DDD, FELICITACIONES!!! TU PRIMER SCRIPT DEL JUEGO YA ESTA FUNCIONANDO!!! *aplausos*
no queda más que felicitarte por leer todo esto jajaja, que igual es bastante, pero quedan las palabras claves muchisimas mas claras y ahi si que cumplen su funcion a la perfeccion, pero..... lamento arruinarte el momento feliz, pero es que hay algo importantisimo que todos los scripts deben tener.
Que pasaria si yo estoy haciendo un juego y lo llevo muy avanzado y se me ocurre hacer un script para mejorarlo, y luego me meto en un juego guardado y veo el script, ooooooh ******* error!!!!!!! D:<
Para esto es que siempre los scripts deben asegurarse que sucede en caso de que antes no habia nada, por ejemplo en nuestro script, si guardamos y colocamos nuestro script despues, el juego guardado ya inicio con todos los initialize de los script y el de nosotros es uno nuevo, como intentara recuperarlo no encontrara nuestra variable de metodo y le restará - 1 cada frames a algo que no existe, entonces pensará, pero que ***** hago si no encuentro esto, entonces te aplaudirá frente a ti diciendo, que se te olvido arreglar eso...
para eso es que nuestro script tenemos que editarlo para que se pueda utilizar en juegos ya guardados, se puede hacer una manera que es la más obvia, que seria sacar la variable de metodo del initialize y ponerla simplemente en el update y nos ahorramos el trabajo de generar algun problema, pues bien, haremos eso...
Sacaremos esa variable y la pondremos en el metodo update y colocaremos el unless para que genere la variable si no estaba antes, con un nil (vacio).
@timer_del_SE = 0 unless @timer_del_SE != nil
Como el initialize no tiene nada lo borramos, quedando asi:
class Game_Player < Game_Character
#--------------------------------------------------------------------
#------------------------- UPDATE -----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_update update
def update
mono_sonidocolision_gameplayer_update
@timer_del_SE = 0 unless @timer_del_SE != nil
@timer_del_SE -= 1 unless @timer_del_SE == 0
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE ----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false && @timer_del_SE == 0
RPG::SE.new("Bite", 80, 100).play
@timer_del_SE = 60
end
return passable
end
end
Listo ahora si el script esta perfecto y no deberia tener ningun problema para utilizarlo :))
hay cosas que los demas scripters hacen y es lo mejor, es que se pueden editar algunas cosas del script y le colocan un mensaje diciendo, aca puedes cambiar el fondo, el volumen, los personajes, el id del battler, etc.
Lo hacen, haciendo que esos datos sean constantes (que no varian en el script), en nuestro script de sonido hay cosas que son constantes, por ejemplo la musica y los 60 frames al que llega el timer, podemos colocar estos datos como constantes, simplemente colocando antes que todo y despues de la class un nombre y el valor que cambiará (logicamente los valores constantes tendriamos que reemplazarlos con esos nombres)
mostraré aca como cambie los valores del cambio de musica y del timer:
class Game_Player < Game_Character
#------------ CAMBIO DE SONIDO -------------------
Camb_sonido = [ "Bite" , 80, 100] # aca se cambia el sonido, el volumen, intensidad
Tiempo_timer= 60 # duracion de espera del sonido
#--------------------------------------------------------------------
#------------------------- UPDATE -----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_update update
def update
mono_sonidocolision_gameplayer_update
@timer_del_SE = 0 unless @timer_del_SE != nil
@timer_del_SE -= 1 unless @timer_del_SE == 0
end
#--------------------------------------------------------------------
#------------------------- MOVIBLE ----------------------------------
#--------------------------------------------------------------------
alias mono_sonidocolision_gameplayer_passable passable?
def passable?(x, y, d)
passable = mono_sonidocolision_gameplayer_passable( x, y, d)
if passable == false && @timer_del_SE == 0
RPG::SE.new(*Camb_sonido).play
@timer_del_SE = Tiempo_timer
end
return passable
end
end
Pues bien, este tutorial nos sirvio más que nada para ver como se utilizan bien las cosas y aprender a editar cosas de los scripts, espero que les sirva, haber si pueden hacer algo mas y nos estaremos viendo para algunos conceptos nuevos y el anexo II para la musica, por lo demás....
Suscribirse a:
Entradas (Atom)