Bonjour,



- Auteur : Samarium
- Créé le 19 Mai 2008
- Version 1
- Incompatibilité : Peu
- Libre d'utilisation et de distribution
- RPG Maker XP

[]Fonctions
Permet de faire parler un évènement dans une/des langue(s) de votre choix. Le héros pourra apprendre ou oublier une/des lettre(s) pour comprendre le langage. Système équivalent au jeu Final Fantasy X (pour les connaisseurs ^^)

[]Caractéristiques et remarque
=> Possibilité de faire apprendre plusieurs langages
=> Apprendre/Oublier une/des lettre(s)
=> Savoir si une lettre/des lettre(s) ont été apprise(s)
=> Afficher ou non une fenêtre au dessus du message avec le nom du langage

Non disponible pour le moment sous RPG Maker VX

[]Screen
[spolier][/spoiler]

[]Démonstration
=> Télécharger Démo Multi Langage Par Samarium (Fichier ZIP ; 217 Ko)

[]Utilisation
Faites un message commençant par [NOM_LANGAGE] où NOM_LANGAGE est le nom du langage défini ci-dessous.

Pour apprendre une/des lettre(s) :
Faites "Insérer un script" dans les commandes d'évènements et :

Code: Tout sélectionner

Language.apprendre("lettre", "langue")

"lettre" est la lettre de votre choix. Pour apprendre plusieurs lettres
en même temps, mettez par exemple :

Code: Tout sélectionner

Language.apprendre("abcdef", "langue")

Le héros apprendra ici, les lettres a,b,c,d,e et f. Pour être plus rapide, mettez :

Code: Tout sélectionner

 Language.apprendre("a-f", "langue")

Ca fera la même chose que précédemment.

Oublier une/des lettre(s) :
Même démarche que pour apprendre sauf que vous mettez :

Code: Tout sélectionner

 Language.oublier("lettre", "langue")

Savoir si une/des lettres a/ont été apprise(s)
Faites "script" dans les conditions des commandes d'évènements et :

Code: Tout sélectionner

Language.estAppris?("lettre", "langue")

Même démarche que précédemment.

Les lettres et les noms des langages sont défnies vers la ligne 63.


[]Installation et scripts
Copiez ce script et collez le au dessus "main" :

Code: Tout sélectionner

=begin
#------------------------------------------------------------------------
#                          Système Multi-langage
#                               RPG Maker XP
#
# Auteur : Samarium
#
# Créé le  19 Mai 2008
#
# Fonction :  Permet de faire parler un évènement dans une/des langue(s) de votre
#             choix. Le héros pourra apprendre ou oublier une/des lettre(s)
#             pour comprendre le langage.
#
# Utilisation : Faites un message commençant par [NOM_LANGAGE] où NOM_LANGAGE est
#               le nom du langage défini ci-dessous.

Pour apprendre une/des lettre(s) :
  Faites "Insérer un script" dans les commandes d'évènements et :
    
             Language.apprendre("lettre", "langue")
     
  "lettre" est la lettre de votre choix. Pour apprendre plusieurs lettres
  en même temps, mettez par exemple :
     
             Language.apprendre("abcdef", "langue")

  Le héros apprendra ici, les lettres a,b,c,d,e et f. Pour être plus rapide, mettez :

             Language.apprendre("a-f", "langue")

  Ca fera la même chose que précédemment.

Oublier une/des lettre(s) :
  Même démarche que pour apprendre sauf que vous mettez :

              Language.oublier("lettre", "langue")
             
Savoir si une/des lettres a/ont été apprise(s)
  Faites "script" dans les conditions des commandes d'évènements et :
      
              Language.estAppris?("lettre", "langue")
             
  Même démarche que précdémment


# Site : www.rpgcreative.net (si besoin d'aide, n'hésitez pas ;))
#
# Remarque : script disponible aussi sous RPG Maker VX
#
#------- Modification ---------

#------------------------------------------------------------------------
=end

module Language
 
  # Si vous mettez "true", une fenêtre avec le nom de la langue s'affichera
  # au dessus du message, efficace lorsqu'il y a plusieurs langues. N'oubliez
  # pas dans ce cas de rajouter le code dans "Window_Message". Mettez "false"
  # pour ne rien afficher.
  AFFICH_WINDOW = true
 
  # Mettez les différents langages : ["nom1", "nom2", "nom3", ...]
  LANGUAGE = ["langue1", "langue2"]
 
  # Mettez les lettres :
  # "Lettre a remplacé" => ["lettre remplacé pour le 1er langage",
  # lettre remplacé pour le 2ème langage, lettre remplacé pour le 3ème langage, ...]
  LETTERS = {
 
  # La lettre a ou A sera remplacée par "z" pour "langue1" et "b" pour "langue2"
  "aAà" => ["z", "b"],
  "bB" => ["e", "n"],
  "cC" => ["r", "s"],
  # La lettre d ou D sera remplacée par "t" pour "langue1" et inchangé pour "langue2"
  "dD" => ["t"],
  "eEéè" => ["y", "p"],
  # La lettre f ou F ou g ou G sera remplacée
  "fFgG" => ["a", "v"],
  "hH" => ["i", "x"],
  "iI" => ["o", "w"],
  "jJ" => ["p", "q"],
  "k" => ["q", "m"],
  "lL" => ["s", "l"],
  "mM" => ["d", "a"],
  "nN" => ["f", "z"],
  "oO" => ["g", "e"],
  "pP" => ["h", "f"],
  "qQ" => ["j", "g"],
  "rR" => ["k", "h"],
  "sS" => ["l", "r"],
  "tT" => ["m", "t"],
  "uU" => ["w", "y"],
  "vV" => ["x", "u"],
  # Les lettres w à Z ou W à Z seront remplacées
  "wW-zZ" => ["v", "k"]
  }
 
 
  class << self
    # Permet d'activer une lettre
    def apprendre(letter, language)
      $game_multi_language[language].activ(letter) if $game_multi_language[language] != nil
    end
   
    # Permet de désactiver une lettre
    def oublier(letter, language)
   
      $game_multi_language[language].activ(letter, false) if $game_multi_language[language] != nil
    end
   
    # Permet de savoir si une lettre est apprise
    def estAppris?(letter, language)
       $game_multi_language[language].activ?(letter) if $game_multi_language[language] != nil
     end
    # alias : on peut écrire la méthode différemment
     alias estappris? estAppris?
     alias est_appris? estAppris?
     alias est_Appris? estAppris?
     alias estAppris estAppris?
   
  end
end

#-------------------------------------------------
#   Scene_Title
#-------------------------------------------------
class Scene_Title
 
   alias language_command_new_game command_new_game
   def command_new_game
     language_command_new_game
     # Construction de la variable globale
     $game_multi_language = {}
     language_name = Language::LANGUAGE
     for i in 0..language_name.size-1
       letters = Language::LETTERS
       tab_keys = letters.keys
       tab_values = construct_tab_language(i, letters.values)
       $game_multi_language[language_name[i]] = Multi_Language.new(tab_keys, tab_values)
     end
  end
 
  # Construit un nouveau tableau avec un booléen pour savoir si la lettre a été
  # apprise ou non
  def construct_tab_language(index_language, tab_values)
    new_tab = []
    for i in 0..tab_values.size-1
      new_tab[i] = [tab_values[i][index_language], false]
    end
    return new_tab
  end
end

#-------------------------------------------------
#   Scene_Save & Scene_Load
#-------------------------------------------------

# Sauvegarde/Charge la variable globale
class Scene_Save < Scene_File
  alias language_write_save_data write_save_data
    def write_save_data(file)
    language_write_save_data(file)
    Marshal.dump($game_multi_language, file) 
    end
  end
class Scene_Load < Scene_File
  alias language_read_save_data read_save_data
    def read_save_data(file)
      language_read_save_data(file)
     $game_multi_language = Marshal.load(file)
    end
end

#-------------------------------------------------
#  Multi_Language
#-------------------------------------------------

class Multi_Language
 
  attr_reader :tab_keys # Tableau contenant les lettres à remplacer
  attr_reader :tabs_values # Tableau contenant les lettres remplacés ainsi que le booléen
 
  # Constructeur
  def initialize(tab_keys, tabs_values)
   @tab_keys = tab_keys
   @tabs_values = tabs_values
  end
 
  # Mets la variable à true ou false selon la /les lettres
  def activ(letter, activ=true)
    for i in 0..@tabs_values.size-1
     @tabs_values[i][1] = activ ? true : false if @tab_keys[i] =~ /[#{letter}]/
    end
  end
 
  # Retourne true si lettre apprise
  def activ?(letter)
    for i in 0..@tabs_values.size-1
     return true if @tabs_values[i][1] if @tab_keys[i] =~ /[#{letter}]/
   end
   return false
  end
end

#-------------------------------------------------
#  Interpreter
#-------------------------------------------------

class Interpreter
 
  alias language_command_101 command_101
  def command_101
    language_command_101
    construct_language($game_temp.message_text)
  end
 
  # Constrution du langage
  def construct_language(string)
   # Si le message commence par [.]
    if /^([[^]]+])/ =~ string
      # Enlève les corchets et récupère le nom de la langue
     language = $&.gsub(/[[]]/, "")
     index_language = Language::LANGUAGE.index(language)
     # Ne fait pas la suite si c'est un langage indéfinie
     return if index_language == nil
     # Enlève le nom dans le message
     string.gsub!(/^([[^]]+])/, "")
     # Prend les lettres à remplacer et les lettres remplacées
     tab_keys = $game_multi_language[language].tab_keys
     tab_values = $game_multi_language[language].tabs_values
     # Transforme déjà les noms particuliers (V[x] ...)
      begin
        last_text = string.clone
        string.gsub!(/\[Vv][([0-9]+)]/) { $game_variables[$1.to_i] }
      end until string == last_text
      string.gsub!(/\[Nn][([0-9]+)]/) {$game_actors[$1.to_i] != nil ? $game_actors[$1.to_i].name : ""}
      string.gsub!(/\\/) { "\000" }
      string.gsub!(/\[Cc][([0-9]+)]/) { "\001[#{$1}]" }
      # nouvelle chaine
      text = construct_string(string.clone)
      for i in 0..tab_keys.size-1
        # Remplace les caractères ayant \0 (permet de remplacer qu'une unique fois
       text.gsub!(/\0[#{tab_keys[i]}]/, "\C[2]" + tab_values[i][0] + "\C[0]") if !tab_values[i][1] and tab_values[i][0] != nil
     end
     # Supprime tout les "\0"
     text.gsub!(/\0/, "")
     # Enregistre le nouveau texte
     $game_temp.message_text = Language::AFFICH_WINDOW ? "\L[" + language + "]" + text : text
    end
  end
 
  # Construction d'une nouvelle chaine
  def construct_string(text)
    new_text = ""
    while ((c = text.slice!(/./m)) != nil)
      # Met "\0" avant chaque caractère
      new_text += "\0#{c}"
    end
    return new_text
  end
end

#-------------------------------------------------
#  Window_Language
#-------------------------------------------------

class Window_Language < Window_Base
  def initialize(language)
    super(80, 240, 300, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 24
    self.opacity = 150
    @language = language
    refresh
  end
  # Affiche le nom de la langue dans une fenêtre
  def refresh
    mot = "Langue :"
    text_size_mot = contents.text_size(mot).width
    text_size_name_language = contents.text_size(@language).width
    self.contents.font.color = system_color
    self.contents.draw_text(text_size_mot, 0, text_size_name_language, 32, @language, 1)
    self.contents.font.size = 20
    self.contents.font.color = normal_color
    self.contents.draw_text(0, 0, text_size_mot, 32, mot, 1)
  end
end

#-------------------------------------------------
#  Window_Message
#-------------------------------------------------

class Window_Message < Window_Selectable
   alias language_terminate_message terminate_message
   def terminate_message
    language_terminate_message
    if @language_window != nil
      @language_window.dispose
      @language_window = nil
    end   
  end
end

A Mettre dans Window_Message :
Remplacez "while ((c = text.slice!(/./m)) != nil)" par

Code: Tout sélectionner

# ------- RAJOUT MULTI-LANGAGE----------
      text.gsub!(/\[Ll][([^]]+)]/) { "\003[#{$1}]" }
      #---------------------------------------
      while ((c = text.slice!(/./m)) != nil) # Déjà existant
      # ------- RAJOUT MULTI-LANGAGE----------
          if c == "\003"
            text.sub!(/[([^]]+)]/, "")
            @language_window = Window_Language.new($1)
          end
      #---------------------------------------