[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Scripts

Salut à tous, je vous présente l'un des premiers scripts utilisant le RGSS Linker.
Ce script est une petite réécriture du module Audio pour utiliser les fonctions qui ont été codées en C/C++ dans les DLLs RGSS FmodEx.dll et RGSS Linker.dll.
RGSS FmodEx.dll est évidemment dépendant de fmodex.dll donc pour éviter les problèmes de dépendances j'ai inclus le fichier dans l'archive suivante : Ressources FModex (Archive Mediafire ; Mise à jour de 2017 pour la dll)
Vous devrez coller les fichiers à la racine de votre projet et tout devrait bien se passer.

Note : Les fichiers ont été analysés avec Kaspersky et ils ne contiennent pas de virus, si un virus est détecté par votre antivirus c'est au faux positif.
Le RGSS Linker est un peu spécial, il lie les fonctions du RGSS de manière dynamique en utilisant une métrique statique. Certains antivirus tel que Avast ont un peu de mal avec ça et s'affolent pour rien.
Note² : Comme le RGSS Linker est prévu pour RGSS104E.dll, il est logique que ceci n'est fonctionnel qu'avec le RGSS1. Cela dit, si des gens ont été assez courageux pour rétro-ingénier le RGSS3, suffira d'envoyer les résultats de la recherche affin de sortir un RGSS3 Linker et de recompiler la DLL RGSS FmodEx

(Ça peut très bien être compilé pour Ruby mais cela ne présente pas de grand intérêt ^^)

Ce script permet de définir les méthodes nécessaires au fonctionnement du script d'après.
A noter que votre projet doit obligatoirement utiliser RGSS104E.dll pour que script fonctionne correctement.

#===
#RGSS Linker (Kernel)
#  Fonction permettant de charger des extensions utilisant le RGSS Linker
#---
#© 2015 - Nuri Yuri (塗 ゆり)
#===
module Kernel
  unless @RGSS_Linker #>Pour éviter le problème du RGSS Reset avec les projets sans loader
    
  @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
  #  Permet de charger une extension RGSS
  #---
  #E : module_filename : String : nom de fichier qui contient l'extension
  #    module_function : String : nom de la fonction qui va charger l'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

Vous devez placer ce script après le script RGSS Linker. L'arborescence des scripts devrait ressembler à ça :
- Plein de scripts
- RGSS Linker
- Audio (FmodEx)
-
- Main

#===
#Audio (FmodEx)
#  Réécriture du module Audio pour intégrer l'utilisation de FmodEx
#---
#© 2015 - Nuri Yuri (塗 ゆり)
#© 2015 - GiraPrimal : Concept LOOP_TABLE
#---
#Script réalisé par des membres de Community Script Project
#===
module Audio
  LOOP_TABLE = [
  # [ "Audio/xxx/Nom_de_fichier", debut, fin ]
  # Ajoutez ici
   
 
  # Note : Pensez à ajouter une virgule après chaque ] 
  #        (sauf pour la dernière ligne et le ] ci-dessous).
  ]
  #---
  #>Mise en minuscule des noms de fichier pour améliorer la recherche
  #---
  LOOP_TABLE.each do |i| i[0].downcase! end
  
  unless @bgm_play #>Pour éviter le problème du RGSSReset
  #===
  #>Chargement et initialisation de FmodEx
  #===
  Kernel.load_module("RGSS FmodEx.dll","Init_FmodEx")
  ::FmodEx.init(32)
  #---
  #>Indication de la lib' utilisée par défauts
  #---
  @library = ::FmodEx
  #---
  #>Sauvegarde des fonctions du RGSS
  #---
  @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)
  #---
  #>Définition des volumes
  #---
  @master_volume = 100
  @sfx_volume = 100
  #===
  #>Définition des extensions supportés par FmodEx
  #===
  EXT = ['.ogg', '.mp3', '.wav', '.mid', '.aac', '.wma', '.it', '.xm', '.mod', '.s3m', '.midi']
  #===
  #>Création/définition des fonctions
  #===
  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
  #  Vérifie la présence du fichier et retourne le nom du fichier existant
  #  /!\ Ne corrige pas la connerie
  #====
  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
  # Fonction permettant de réaliser automatiquement l'appel de 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

Note : les début et fin contenus dans LOOP_TABLE doivent être exprimés en millisecondes. Ils ne s'appliquent que pour les BGM et BGS.

Voici la liste des méthodes de la classe FmodEx::Sound.
Notez qu'à l'exception d'initialize, toutes les méthodes sont susceptibles de retourner nil (dans le cas où le son n'est plus utilisable).
Pensez à toujours vérifiquer que le résultat vaut autre chose que nil avant de l'utiliser dans des calculs.

Vous pouvez aussi créer un son indépendamment des BGM, BGS, ME et SE en utilisant la méthode new de FmodEx::Sound (avec les arguments de sa méthode initialize).
_____
initialize(filename, volume = 100, pitch = 100, position = 0, looping = true, streaming = true, *args)
Initialise un son
Arguments : filename, volume, pitch, position, looping, streaming, memory_data, dls_file_name
Optionnels à partir de volume (inclut)
Si position est inférieur à 0, le son sera initialement en pause
memory_data correspond à une chaine contenant le contenu du fichier.
dls_file_name correspond au nom du fichier dls à charger pour les midis.

_____
stop
Arrêt d'un son (relache automatiquement la channel et le sound)
Retourne true si l'arrêt a été effectué, false si l'arrêt n'est pas possible
Lève une exception FmodEx::Error si FmodEx échoue et qu'aucun Thread de Fade est associé au sound.

_____
fade(time_ms)
Fade out d'un son
L'utilisateur indique le temps en millisecondes
Retourne true si le fade du sound a été déclenché, false sinon

_____
pause(pause_state)
Mise en pause d'un son
L'utilisateur indique si il veut que le son soit en pause (true) ou joué (false)
Retourne le statut de pause demandé, ou nil si cela n'est pas possible
Lève une exception FmodEx::Error si FmodEx ne peut pas mettre le son en pause

_____
paused?
Récupération du statut "pause" d'un son
Retourne true si le son est en pause, false sinon
Lève une exception FmodEx::Error si FmodEx ne peut pas récupérer le statut

_____
set_loop_points(begin_pt, end_pt)
Indiquer les points de boucle du son
Si le son est bouclé, l'utilisateur peut indiquer le début et la fin de la boucle en millisecondes
Retourne true si cela a été réalisé, nil si cela n'est pas possible
Lève une exception FmodEx::Error si FmodEx ne parvient pas à enregistrer les points de boucle

_____
set_looping(state)
Indiquer la possibilité de boucler
L'utilisateur indique si il veut (true) ou non (false) que le son soit joué en boucle
Retourne le statut demandé, nil si cela n'est pas possible
Lève une exception FmodEx::Error si FmodEx ne parvient pas à modifier le statut du son

_____
looping?
Retourne si le son est joué ou non en boucle
Lève une exception FmodEx::Error si FmodEx ne parvient pas à récupérer le statut

_____
set_position(position_ms)
Indiquer la position de lecture du son
L'utilisateur indique la position en milliseconde de la lecture du son
Retourne la position demandé si elle a pu être enregistrée
Lève une exception FmodEx::Error si FmodEx ne parvient pas à modifier la position

_____
get_position
Retourne la position actuelle de la lecture du son
Lève une exception FmodEx::Error si FmodEx échoue

_____
set_volume(volumeà
Indication du volume du son
L'utilisateur indique le volume qu'il désire entre 0 et 100
Retourne le volume demande si réalisé
Lève une exception FmodEx::Error si FmodEx échoue

_____
get_volume
Retourne le volume du son
Lève une exception FmodEx::Error si FmodEx ne parvient pas à retrouver le volume

_____
set_frequency(frequency)
Indiquer la fréquence de lecture du son
L'utilisateur indique la fréquence à laquelle il veut que le son soit joué
Retourne la fréquence indiqué si cela a été réalisé
Lève une exception FmodEx::Error si FmodEx n'a pas pu changer la fréquence de lecture

_____
get_frequency
Récupérer la fréquence de lecture du son
Lève une exception FmodEx::Error si FmodEx n'a pas pu retrouver la fréquence de lecture du son

_____
set_pan(pan)
Indiquer la balance du son (-100 = gauche, 0 = centre, 100 = droite)
Retourne la valeur demandée
Lève une exception FmodEx::Error si FmodEx ne parvient pas à modifier la balance.

_____
get_pan
Récupérer la balance du son
Lève un exception FmodEx::Error si FmodEx ne parvient pas à retrouver la balance

_____
playing?
Savoir si FmodEx joue actuellement le son
Retourne true si c'est le cas
Lève une exception FmodEx::Error si FmodEx ne parvient pas à savoir ce qu'il fait de ce son

_____
length
Récupérer la longueur temporelle totale du son en millisecondes
Lève une exception FmodEx::Error si FmodEx ne parvient pas à retrouver la longueur du son

_____
FmodEx.init(nb_of_channels)
Initialisation de FmodEx
L'utilisateur indique le nombre de channel désiré et la fonction
Retourne true si réussi, false si déjà initialisé
Lève une exception FmodEx::Error si FmodEx échoue dans sa tâche.

_____
FmodEx.bgm_play(filename, volume = 100, pitch = 100, streaming = true, *args)
Lire un BGM.
Retourne le son du BGM en lecture.
Arguments : filename [,volume [, pitch [, streaming [, memory [, dls]]]]]
memory correspond au data en RAM du fichier audio.
dls correspond au nom du fichier dls à utiliser avec les midis.

_____
FmodEx.bgm_stop
Arrêt d'un BGM.

_____
FmodEx.bgm_fade(time_ms)
Fade out du BGM l'utilisateur indique le temps de fade en millisecondes.

_____
FmodEx.bgm_sound
Récupérer l'objet FmodEx::Sound du BGM.
Peut-être nil si aucun BGM n'est joué.

_____
FmodEx.bgs_play(filename, volume = 100, pitch = 100, streaming = true, *args)
Lire un BGS.
Retourne le son du BGS en lecture.
Arguments : filename [,volume [, pitch [, streaming [, memory [, dls]]]]]
memory correspond au data en RAM du fichier audio.
dls correspond au nom du fichier dls à utiliser avec les midis.

_____
FmodEx.bgs_stop
Arrêt d'un BGS.

_____
FmodEx.bgs_fade(time_ms)
Fade out du BGS l'utilisateur indique le temps de fade en millisecondes.

_____
FmodEx.bgs_sound(filename, volume = 100, pitch = 100, streaming = true, *args)
Récupérer l'objet FmodEx::Sound du BGS.
Peut-être nil si aucun BGS n'est joué.

_____
FmodEx.me_play
Lire un ME.
Retourne le son du me en lecture.
Arguments : filename [,volume [, pitch [, streaming [, memory [, dls]]]]]
memory correspond au data en RAM du fichier audio.
dls correspond au nom du fichier dls à utiliser avec les midis.

_____
FmodEx.me_stop
Arrêt d'un ME.

_____
FmodEx.fade_out(time_ms)
Fade out du ME l'utilisateur indique le temps de fade en millisecondes.

_____
FmodEx.me_sound
Récupérer l'objet FmodEx::Sound du me.
Peut-être nil si aucun ME n'est joué.

_____
FmodEx.se_play(filename, volume = 100, pitch = 100, streaming = true, *args)
Lire un SE.
Retourne le son du se en lecture.
Arguments : filename [,volume [, pitch [, streaming [, memory [, dls]]]]]
memory correspond au data en RAM du fichier audio.
dls correspond au nom du fichier dls à utiliser avec les midis.

_____
FmodEx.se_stop
Arrêt des SE.

FIRELIGHT TECHNOLOGIES PTY LTD. - API FMOD Ex
Enterbrain - RGSS
Nuri Yuri - RGSS Linker, RGSS FmodEx, Audio (FmodEx)
GiraPrimal - LOOP_TABLE

Voilà, je pense que la chose est assez complète, si vous souhaitez utiliser le RGSS Linker passez par ici : https://github.com/NuriYuri/RGSS-Linker