Registrarse

[RPGXP] Como loopear música

AlanVenator

Usuario Inusual
En este tutorial os voy a enseñar a insertar música en Rpg like a boss loopeada. Haciendo esto reduciremos el peso de nuestro proyecto a la vez que le damos un toque mucho más profesional a nuestro juego.

Si habéis probado a insertar una canción loopeada en Rpg XP os habréis dado cuenta de que no se loopea (hay un silencio y se vuelve a reproducir desde el inicio). Esto es porque RPG XP de por si no reconoce archivos de audio con un loop, aunque curiosamente Rpg Maker VX sí.

Así que este tutorial se dividirá en dos partes:

Vamos a usar un script hecho por Nuri Yuri(no olvidéis darle créditos) que hará que RPG Maker reconozca los archivos de audio loopeados.

Podéis entrar directamente el post principal del script en Pokeco y seguir las instrucciones allí https://www.pokecommunity.com/showthread.php?t=349496
Allí encontraréis links de descarga a archivos y más información sobre el script, yo sólo voy a explicar como se instala.


Primero necesitáis todos estos archivos:
-fmodex.dll
-RGSS FmodEx.dll
-RGSS Linker.dll
-RGSS104E.dll

Los podeis descargar del post que he dejado antes, pero como soy buena gente he juntado los archivos en una carpeta que podéis descargar desde aquí.

Nota: en la carpeta hay un archivo nombrado RGSS102E.dll, es el archivo RGSS104E.dll sólo que tiene el nombre cambiado para que al copiar y pegar en la carpeta de nuestro proyecto se sobreescriba un archivo por otro.

- Copiamos y pegamos los archivos en el directorio principal de nuestro proyecto.


- Abrimos nuestro proyecto de RPG Maker XP, nos vamos a Script editor y le damos a insertar, y copiamos lo siguiente:

#===
#RGSS Linker (Kernel)
# Function that helps the load of extentions using RGSS Linker.
#---
#© 2015 - Nuri Yuri (塗 ゆり)
#===
module Kernel
unless @RGSS_Linker #>To avoid the RGSS Reset problem

@RGSS_Linker = {:core => Win32API.new("RGSS Linker.dll","RGSSLinker_Initialize","p","i")}
Win32API.new("kernel32","GetPrivateProfileString","ppppip","i").call("Game","Library",0,lib_name = "\x00"*32,32,".//Game.ini")
raise LoadError, "Failed to load RGSS Linker." unless(@RGSS_Linker[:core].call(lib_name)==1)
lib_name = nil
module_function
#===
#>Kernel.load_module
# Helps to load a RGSS extension
#---
#I : module_filename : String : Name of the file which contains the extension
# module_function : String : Name of the function that will load the extension
#===
def load_module(module_filename, module_function)
return if @RGSS_Linker[module_filename]
mod = @RGSS_Linker[module_filename] = Win32API.new(module_filename, module_function, "", "")
mod.call
end

end #>unless @RGSS_Linker
end

- Insertamos otro script DEBAJO del anterior y copiamos esto.

#===
#Audio (FmodEx)
# A rewrite of Audio module to integrate FmodEx
#---
#© 2015 - Nuri Yuri (塗 ゆり)
#© 2015 - GiraPrimal : Concept of LOOP_TABLE
#---
#Script written by the menbers of the Community Script Project
#===
module Audio
LOOP_TABLE = [
# [ "Audio/xxx/File_name", begin, end ]
# Add here


# Note : Renember to add a comma after each ]
# (except for the last line and the below ]).
]
#---
#>Puts the file names in lowercase to improve the search
#---
LOOP_TABLE.each do |i| i[0].downcase! end

unless @bgm_play #>To avoid the RGSSReset problem
#===
#>Load and initialize FmodEx
#===
Kernel.load_module("RGSS FmodEx.dll","Init_FmodEx")
::FmodEx.init(32)
#---
#>Indication of the default lib'
#---
@library = ::FmodEx
#---
#>Saving the RGSS functions
#---
@bgm_play = method:)bgm_play)
@bgm_fade = method:)bgm_fade)
@bgm_stop = method:)bgm_stop)
@bgs_play = method:)bgs_play)
@bgs_fade = method:)bgs_fade)
@bgs_stop = method:)bgs_stop)
@me_play = method:)me_play)
@me_fade = method:)me_fade)
@me_stop = method:)me_stop)
@se_play = method:)se_play)
@se_stop = method:)se_stop)
#---
#>Volumes definition
#---
@master_volume = 100
@sfx_volume = 100
#===
#>Extensions supported by FmodEx
#===
EXT = ['.ogg', '.mp3', '.wav', '.mid', '.aac', '.wma', '.it', '.xm', '.mod', '.s3m', '.midi']
#===
#>Creation/definition of the functions
#===
module_function
def bgm_play(file_name, volume = 100, pitch = 100)
volume = volume * @master_volume / 100
return @bgm_play.call(file_name, volume, pitch) if(@library != ::FmodEx)
filename = check_file(file_name)
bgm = ::FmodEx.bgm_play(filename, volume, pitch)
loop_audio(bgm, file_name)
end
def bgm_fade(time)
return @bgm_fade.call(time) if(@library != ::FmodEx)
::FmodEx.bgm_fade(time)
end
def bgm_stop
return @bgm_stop.call if(@library != ::FmodEx)
::FmodEx.bgm_stop
end
def bgs_play(file_name, volume = 100, pitch = 100)
volume = volume * @sfx_volume / 100
return @bgs_play.call(file_name, volume, pitch) if(@library != ::FmodEx)
filename = check_file(file_name)
bgs = ::FmodEx.bgs_play(filename, volume, pitch)
loop_audio(bgs, file_name)
end
def bgs_fade(time)
return @bgs_fade.call(time) if(@library != ::FmodEx)
::FmodEx.bgs_fade(time)
end
def bgs_stop
return @bgs_stop.call if(@library != ::FmodEx)
::FmodEx.bgs_stop
end
def me_play(file_name, volume = 100, pitch = 100)
volume = volume * @master_volume / 100
return @me_play.call(file_name, volume, pitch) if(@library != ::FmodEx)
file_name = check_file(file_name)
::FmodEx.me_play(file_name, volume, pitch)
end
def me_fade(time)
return @me_fade.call(time) if(@library != ::FmodEx)
::FmodEx.me_fade(time)
end
def me_stop
return @me_stop.call if(@library != ::FmodEx)
::FmodEx.me_stop
end
def se_play(file_name, volume = 100, pitch = 100)
volume = volume * @sfx_volume / 100
return @se_play.call(file_name, volume, pitch) if(@library != ::FmodEx)
file_name = check_file(file_name)
::FmodEx.se_play(file_name, volume, pitch)
end
def se_stop
return @se_stop.call if(@library != ::FmodEx)
::FmodEx.se_stop
end
#===
#>check_file
# Check the presence of the file and return the filename
# /!\ Doesn't correct the mistake
#====
def check_file(file_name)
return file_name if File.exist?(file_name)
EXT.each do |ext|
filename = file_name+ext
return filename if File.exist?(filename)
end
return file_name
end
#===
#>loop_audio
# Function that automatically call the set_loop_points
#===
def loop_audio(sound, file_name)
filename = file_name.downcase
LOOP_TABLE.each do |i|
if(i[0] == filename)
return sound.set_loop_points(i[1], i[2])
end
end
end
end
end

- Listo!

Créditos:
FIRELIGHT TECHNOLOGIES PTY LTD. - FMOD Ex API
Enterbrain - RGSS
Nuri Yuri - RGSS Linker, RGSS FmodEx, Audio (FmodEx)
GiraPrimal - LOOP_TABLE
Para loopear un archivo de audio, primero necesitaremos un programa de edición de audio, os recomiendo Audacity, ya que es totalmente gratis. Lo podéis descargar aquí: Download | Audacity®
Por supuesto también necesitamos una canción para loopear, en mi caso usaré Shifty Boo Mansion del videojuego Super Mario 3D World.

- Una vez instalado el audacity lo abrimos y arrastramos la canción.

- Debemos identificar el patrón que se repite en la canción (esta es la parte más difícil). Os podéis ayudar de lo que se ve en el audacity, si os fijáis la parte subrayada en verde y la parte en rojo son iguales (la melodía principal por así decirlo). Así que todo lo que viene después de la zona verde no lo vamos a necesitar.



-Estableceremos la zona de loop en la melodía principal, de esta forma se reproducirá la canción entera una vez, primero la intro, luego la melodía principal y luego se repetirá indefinidamente lo que hayamos puesto en la zona de loop.



- Para establecer la zona de loop, nos ayudaremos de dos marcas, para insertarlas nos vamos a Pistas --> Añadir etiqueta en la selección o simplemente Ctrl + B.



- Ahora hay que ajustar la colocación de las etiquetas, tienen que quedar las dos en la misma posición respecto a la melodía, (para que no haya ningún salto raro en la canción). El sitio ideal es justo antes de una onda, en un punto de silencio, es decir, que la onda pase por el 0, el eje horizontal. (Con esto conseguimos evitar el ruido "click" tan característico que se produce al loopear mal una canción). Nos ayudamos del zoom para tener una mejor visión.




- Comprobamos que hemos ajustado bien, para ello seleccionamos toda la región del bucle, pulsamos Shift y le damos al play para reproducir cíclicamente. Si al pasar del final del bucle al principio no escuchamos nada extraño y el cambio es fluido, es que hemos ajustado bien.



- Borramos todo desde el final del bucle hasta el final de la canción (con esto reducimos peso del archivo).

- Antes de exportar, debemos irnos a la parte de abajo del programa y con el botón derecho cambiar el formato a samples. También hay que asegurarse de que está seleccionado longitud en vez de final.





- Volvemos a seleccionar el área del bucle y le damos a exportar (Archivo --> Exportar audio) Como formato ponemos "Archivos Ogg Vorbis" y en calidad pues la que veáis conveniente, yo la suelo poner a la mitad más o menos. Si pesa mucho el archivo pues reduzco un poco la calidad.

- Una vez hecho eso nos sale Editar etiquetas de metadatos y añadimos dos etiquetas, una que se llame "LOOPSTART" y otra "LOOPLENGTH". En los valores ponemos los de comienzo de selección y los de longitud.



- Le damos a aceptar y listo, ya tenemos una canción loopeada lista para insertar en nuestro proyecto de RPG Maker XP.


He subido el resultado final de mi canción loopeada, para que podáis ver qué tal queda, además de comprobar que hemos hecho el primer paso bien.Descargar

Parece un poco engorroso, pero es más fácil de lo que parece. Espero que se entienda todo.
 

kanda

Creador de Pokémon HighSchool
Wow. Estamos a tope con tutoriales super interesantes *O*
@AlanVenator me ha encantado el tutorial tío! Ahora mismo no lo voy a hacer pero fiiiiiiijo que me pongo a ello pronto. De momento está página va a favoritos.

Siempre me he preguntado cómo haría eso la gente y ahora ya tengo la respuesta :D además lo de bajar el peso de la música es clave!

¡¡Muchas gracias por el tutorial!!
 
Arriba