miércoles, 28 de agosto de 2013

Conceptos Basicos X: attr_

  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.

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...


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 :

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...





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.

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...