=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