____

Scripts RPG Maker XP

- Totalité

Nombre de scripts : 105
Derniers scripts :

Changer la taille de l'écran de votre jeu

Système Online - Net RMXP 2008

Combat ADB (comme Final Fantasy 12)

Système Multi-langage

Auteur : Samarium

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. Système équivalent au jeu Final Fantasy X (pour les connaisseurs ^^)

Image(s) : Image n°1

Ressource(s) : Aucune

Démo : Télécharger le fichier ( 218 Ko ; Fichier ZIP)

Remarque : Testé et fonctionnel
=> 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

Nombre de scripts : 1

Installation : Copiez le code, ouvrez l'éditeur de script ( F11 ) et créez en un nouveau au dessus de 'Main'
et collez le code.

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:

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

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

Code:

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

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

Code:

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:

 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:

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.

Code :

=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

remplacez dans le script Window_Message la ligne :

while ((c = text.slice!(/./m)) != nil

par

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

Informations

Page vue 1565554 fois | Auteur : Samarium