SHARE
TWEET

Multilanguage Script

Holy87 May 28th, 2015 (edited) 358 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. =begin
  3.  ==============================================================================
  4.   ■ Localizzazione del gioco di Holy87
  5.       versione 1.0.3
  6.       Difficoltà utente: ★★★
  7.       Licenza: CC. Chiunque può scaricare, modificare, distribuire e utilizzare
  8.       lo script nei propri progetti, sia amatoriali che commerciali. Vietata
  9.       l'attribuzione impropria.
  10.  ==============================================================================
  11.     Questo script permette al gioco di essere multilingua! Si possono creare
  12.     file della lingua diversi per poter permettere ai giocatori di giocare alla
  13.     loro lingua madre.
  14.  ==============================================================================
  15.   ■ Compatibilità
  16.     DataManager -> alias load_normal_database
  17.     Bitmap -> alias initialize, draw_text
  18.  ==============================================================================
  19.   ■ Changelog
  20.     25/06/2015 -> v1.0.3
  21.     ● È possibile interpolare stringhe semplici con stringhe localizzate, ad
  22.       esempio "{S: hello} Eric!" -> "Ciao Eric!"
  23.     ● È possibile inserire più chiavi localizzate in una sola stringa, ad esempio
  24.       "{S: hello} {S: friends}" -> "Ciao amici"
  25.     23/06/2015 -> v1.0.2
  26.     ● Risolto il bug per i due punti : nei messaggi
  27.     ● Risolto il bug del tag nome eroe nei messaggi \n
  28.     ● Risolto il glitch per la finestra delle scelte dei messaggi
  29.     07/06/2015 -> v1.0.1
  30.     ● Ora se una stringa nella lingua selezionata non è stata trovata, prende
  31.       la stringa dalla lingua standard se c'è, altrimenti dalla lingua predefinita
  32.       invece di mostrare una stringa vuota.
  33.     ● Altri bugfix
  34.  ==============================================================================
  35.   ■ Installazione e istruzioni
  36.     Installare questo script sotto Materials e prima del Main.
  37.     RICHIEDE IL MODULO DI SUPPORTO UNIVERSALE DI HOLY87.
  38.     Lo script delle opzioni di gioco, se presente, deve stare sopra di questo
  39.     script.
  40.    
  41.   ■ Istruzioni per come impostare il gioco
  42.      
  43.     ● Prima di tutto, creare la cartella Localization all'interno della
  44.       cartella principale del progetto. All'interno di questo bisogna creare
  45.       tanti file quante le lingue volute. Esempio: Voglio creare il file della
  46.       lingua italiana. Creo il file it.ini, dove it è il diminutivo di italiano
  47.       e ini è l'estensione del file (basta cambiare .txt in .ini). È importante
  48.       che la lingua abbia l'estensione del file scelta.
  49.       Apri il file, e la prima cosa da creare all'interno è un tag dove inserirci
  50.       le informazioni sulla lingua. Quindi
  51.       <header>
  52.       Language:Italiano
  53.       ID:1040
  54.       </header>
  55.       Language è la lingua mostrata nelle opzioni, mentre ID è l'ID della lingua
  56.       del sistema, in modo che se la lingua di Windows è impostata in Italiano,
  57.       il gioco partirà direttamente con la lingua italiana. Tutti i codici delle
  58.       lingue puoi trovarli a questa pagina
  59.       http://support.microsoft.com/kb/193080
  60.       https://msdn.microsoft.com/en-US/library/ee825488(v=cs.20).aspx
  61.      
  62.     ● La seconda cosa da fare è creare le stringhe che ci servono vengano messe
  63.       nel gioco. Crea il tag strings come abbiamo fatto con header. Ad esempio
  64.       <strings>
  65.       greetings:Ciao!
  66.       defeat:Sei stato sconfitto.
  67.       </strings>
  68.       È importante che le stringhe siano SULLA STESSA RIGA. Metti il simbolo \n
  69.       se vuoi che il testo vada a capo nel gioco.
  70.      
  71.     ● Nel gioco, metti il tag {S: NomeStringa} per sostituire il testo con la
  72.       stringa nell'appropriato file della lingua. Ad esempio, se in un messaggio
  73.       del gioco o in qualsiasi altra parte scriverai {S: greetings}, al momento
  74.       del gioco, se impostata la lingua italiana, il giocatore vedrà la scritta
  75.       Ciao! al posto del tag.
  76.       Funziona anche con gli oggetti del database e tutti gli script che hai
  77.       installato!
  78.      
  79.     ● In verità, c'è un altro modo per gli oggetti del database. Puoi creare
  80.       altri tag con header items, skills, ecc... contenenti le informazioni di
  81.       ogni elemento del database per attributi. Ad esempio, scrivendo
  82.       <skills>
  83.       ID:1, name:Attacca, description:Attacca con l'arma equipaggiata; message1: attacca!
  84.       </skills>
  85.       Il punto e virgola separa gli attributi. Per mostrare il ; nel gioco,
  86.       scrivi \;
  87.       La skill 1 del database avrà nome, descrizione e messaggio indicati nel
  88.       file della lingua. Una volta ultimato non resterà che modificare il file
  89.       per le altre lingue.
  90.      
  91.     ● E per le immagini?
  92.       Nel caso tu abbia delle immagini che mostrano un testo e vuoi mostrare
  93.       un'immagine differente a seconda della lingua selezionata, basterà mettere
  94.       più immagini con la differenza che nel nome finale metto _lingua.
  95.       Ad esempio, se ho un'immagine chiamata Nuvola.png nella cartella Pictures,
  96.       creo l'immagine Nuvola_it.png e Nuvola_fr.png nella stessa cartella.
  97.       Se il gioco ha la lingua italiana, quando andrò a caricare Nuvola vedrò
  98.       l'immagine Nuvola_it, mentre in francese Nuvola_en e in tutte le altre
  99.       lingue la classica Nuvola.
  100.  ==============================================================================
  101. =end
  102. #==============================================================================
  103. # ** SETTINGS
  104. #------------------------------------------------------------------------------
  105. #  Imposta le opzioni dello script
  106. #==============================================================================
  107. module H87Localization
  108.   module Settings
  109.     #--------------------------------------------------------------------------
  110.     # * Lingua predefinita se non è installata quella del sistema
  111.     #--------------------------------------------------------------------------
  112.     DEFAULT_LANGUAGE = "en"
  113.     #--------------------------------------------------------------------------
  114.     # * Cartella dei file della lingua
  115.     #--------------------------------------------------------------------------
  116.     LANG_FOLDER = "Localization"
  117.     #--------------------------------------------------------------------------
  118.     # * Comando nelle opzioni
  119.     #--------------------------------------------------------------------------
  120.     OPTION_LANGUAGE = "{S: Lang_Option}"
  121.     #--------------------------------------------------------------------------
  122.     # * Descrizione del comando nelle opzioni
  123.     #--------------------------------------------------------------------------
  124.     OPTION_DESCRIPTION = "{S: Lang_Description}"
  125.   end
  126. end
  127.  
  128. #---------------------------- FINE CONFIGURAZIONE ------------------------------
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139. $imported = {} if $imported == nil
  140. $imported["H87_Localization"] = true
  141.  
  142. #==============================================================================
  143. # ** module H87Localization
  144. #------------------------------------------------------------------------------
  145. #  Module for language-check processing.
  146. #==============================================================================
  147. module H87Localization
  148.                          
  149.   REG_EXCAPE = /\{S:[ ]+(.+?)\}/
  150.   #--------------------------------------------------------------------------
  151.   # * Gets a string. If it contains a reference to a localized strings, returns
  152.   #   the localized strings. Otherwise, the string itself.
  153.   #   str: string to check
  154.   #--------------------------------------------------------------------------
  155.   def self.check_localized_string(str)
  156.     DataManager.load_localization if $data_localization.nil?
  157.     r = REG_EXCAPE
  158.     return str.to_s.gsub(r){|s|get_localized_string($1) if s =~ r}
  159.   end
  160.   #--------------------------------------------------------------------------
  161.   # * Returns the selected language (if set by user or system default)
  162.   #--------------------------------------------------------------------------
  163.   def self.selected_system_language
  164.     DataManager.load_h87settings unless $game_settings
  165.     if $game_settings["sys_lang"].nil?
  166.       return default_game_language
  167.     else
  168.       return $game_settings["sys_lang"]
  169.     end
  170.   end
  171.   #--------------------------------------------------------------------------
  172.   # * Returns the default language if not setted by user
  173.   #--------------------------------------------------------------------------
  174.   def self.default_game_language
  175.     proper_l(system_language)
  176.   end
  177.   #--------------------------------------------------------------------------
  178.   # * Returns the Windows language.
  179.   #--------------------------------------------------------------------------
  180.   def self.system_language
  181.     code = Win.language
  182.     return default_language if lang_from_code(code).nil?
  183.     return lang_from_code(code)
  184.   end
  185.   #--------------------------------------------------------------------------
  186.   # * Checks if there is the language with sub-language, otherwise returns
  187.   #   the traditional language
  188.   #--------------------------------------------------------------------------
  189.   def self.proper_l(lang)
  190.     if language_avaiable?(lang)
  191.       return lang
  192.     else
  193.       return dialet?(lang) ? proper_l(base_language(lang)) : default_language
  194.     end
  195.   end
  196.   #--------------------------------------------------------------------------
  197.   # * Returns the traditional language from the dialet.
  198.   #   lang: language (i.e. "en-uk" -> "en")
  199.   #--------------------------------------------------------------------------
  200.   def base_language(lang)
  201.     return lang unless dialet?(lang)
  202.     return lang.split("-")[0]
  203.   end
  204.   #--------------------------------------------------------------------------
  205.   # * Returns the language short name (es. "en") from a code (es. 1033)
  206.   #--------------------------------------------------------------------------
  207.   def self.lang_from_code(code)
  208.     installed_languages.each do |language|
  209.       return language.short if language.id == code
  210.     end
  211.     return nil
  212.   end
  213.   #--------------------------------------------------------------------------
  214.   # * Return true if a language is installed
  215.   #   lang: language short name
  216.   #--------------------------------------------------------------------------
  217.   def self.language_avaiable?(lang)
  218.     installed_languages.each do |language|
  219.       return true if lang == language.short
  220.     end
  221.     return false
  222.   end
  223.   #--------------------------------------------------------------------------
  224.   # * Return the language file name
  225.   #   lang: language short name
  226.   #--------------------------------------------------------------------------
  227.   def self.language_file(lang)
  228.     language_folder+"/#{lang}.ini"
  229.   end
  230.   #--------------------------------------------------------------------------
  231.   # * Return the language files folder
  232.   #--------------------------------------------------------------------------
  233.   def self.language_folder
  234.     return Settings::LANG_FOLDER
  235.   end
  236.   #--------------------------------------------------------------------------
  237.   # * Return the default language when the player's language is not avaiable
  238.   #--------------------------------------------------------------------------
  239.   def self.default_language
  240.     Settings::DEFAULT_LANGUAGE
  241.   end
  242.   #--------------------------------------------------------------------------
  243.   # * Return true if the language is a traditional language or a sub-language.
  244.   #   lang: language. I.E.: en-uk => true, en => false
  245.   #--------------------------------------------------------------------------
  246.   def self.dialet?(lang)
  247.     return lang =~ /[.]+\-[.]+/
  248.   end
  249.   #--------------------------------------------------------------------------
  250.   # * Return the avaiable languages list
  251.   #--------------------------------------------------------------------------
  252.   def self.installed_languages
  253.     @languages = check_installed_languages if @languages.nil?
  254.     return @languages
  255.   end
  256.   #--------------------------------------------------------------------------
  257.   # * Checks all the languages in language folder.
  258.   #--------------------------------------------------------------------------
  259.   def self.check_installed_languages
  260.     languages = []
  261.     Dir.foreach(language_folder) {|x|
  262.       next if x == "." or x == ".."
  263.       file_name = language_folder+"/"+x
  264.       next if File.directory?(file_name)
  265.       dl = Data_Localization.new
  266.       File.open(file_name,"r") do |file|
  267.         if dl.language_ok?(file.read)
  268.           short = File.basename(file_name,".*")
  269.           name = dl.lang_name
  270.           id = dl.lang_id
  271.           languages.push(Language.new(id, short, name))
  272.         end
  273.       end
  274.     }
  275.     return languages
  276.   end
  277.   #--------------------------------------------------------------------------
  278.   # * Return the Option hash (if Option Menu is installed)
  279.   #--------------------------------------------------------------------------
  280.   def self.create_option
  281.     { :type => :variable,
  282.       :text => Settings::OPTION_LANGUAGE,
  283.       :help => Settings::OPTION_DESCRIPTION,
  284.       :var  => "sys_lang",
  285.       :default => default_game_language,
  286.       :open_popup => true,
  287.       :method => :update_language,
  288.       :values => installed_languages_names
  289.     }
  290.   end
  291.   #--------------------------------------------------------------------------
  292.   # * Return the name of all avaiable languages
  293.   #--------------------------------------------------------------------------
  294.   def self.installed_languages_names
  295.     hash = {}
  296.     for language in installed_languages
  297.       hash[language.short] = language.name
  298.     end
  299.     return hash
  300.   end
  301.   #--------------------------------------------------------------------------
  302.   # * Return the proper string from a tag.
  303.   #--------------------------------------------------------------------------
  304.   def self.get_localized_string(string_id)
  305.     DataManager.load_localization unless $data_localization
  306.     return $data_localization.get_string(string_id)
  307.   end
  308. end
  309.  
  310. #==============================================================================
  311. # ** class Option
  312. #------------------------------------------------------------------------------
  313. #  Loading language after selecting a new lang.
  314. #==============================================================================
  315. class Option
  316.   #--------------------------------------------------------------------------
  317.   # * Reload the language after selection
  318.   #--------------------------------------------------------------------------
  319.   def update_language(lang)
  320.     DataManager.load_localization unless $data_localization
  321.     $data_localization.load_language(lang)
  322.   end
  323. end
  324.  
  325. #==============================================================================
  326. # ** Bitmap
  327. #------------------------------------------------------------------------------
  328. #  Methods for taking the right bitmap and draw proper text
  329. #==============================================================================
  330. class Bitmap
  331.   #--------------------------------------------------------------------------
  332.   # * Alias
  333.   #--------------------------------------------------------------------------
  334.   alias h87localization_dt draw_text unless $@
  335.   alias h87localization_init initialize unless $@
  336.   #--------------------------------------------------------------------------
  337.   # * Object initialization
  338.   #--------------------------------------------------------------------------
  339.   def initialize(*args)
  340.     if args[0].is_a?(String)
  341.       begin
  342.         DataManager.load_h87settings unless $game_settings
  343.         DataManager.load_localization unless $data_localization
  344.         args2 = args.clone
  345.         args2[0]+="_#{$game_settings["sys_lang"]}"
  346.         h87localization_init(*args2)
  347.       rescue
  348.         h87localization_init(*args)
  349.       end
  350.     else
  351.       h87localization_init(*args)
  352.     end
  353.   end
  354.   #--------------------------------------------------------------------------
  355.   # * draw_text
  356.   #--------------------------------------------------------------------------
  357.   def draw_text(*args)
  358.     a_index = args[0].is_a?(Rect) ? 1 : 4
  359.     args[a_index] = H87Localization.check_localized_string(args[a_index])
  360.     h87localization_dt(*args)
  361.   end
  362. end
  363.  
  364. #==============================================================================
  365. # ** class Object
  366. #------------------------------------------------------------------------------
  367. #  Changing sprintf method
  368. #==============================================================================
  369. class Object
  370.   alias unlocalized_sprintf sprintf unless $@
  371.   #--------------------------------------------------------------------------
  372.   # * sprintf
  373.   #--------------------------------------------------------------------------
  374.   def sprintf(*args)
  375.     args[0]=H87Localization.check_localized_string(args[0])
  376.     unlocalized_sprintf(*args)
  377.   end
  378. end
  379.  
  380. #==============================================================================
  381. # ** class Language
  382. #------------------------------------------------------------------------------
  383. #  A simple class for handling languages
  384. #==============================================================================
  385. class Language
  386.   #--------------------------------------------------------------------------
  387.   # * Public instance variables
  388.   #--------------------------------------------------------------------------
  389.   attr_accessor :id
  390.   attr_accessor :short
  391.   attr_accessor :name
  392.   #--------------------------------------------------------------------------
  393.   # * Object initialization
  394.   #--------------------------------------------------------------------------
  395.   def initialize(id, short, name)
  396.     @id = id.to_i
  397.     @short = short
  398.     @name = name
  399.   end
  400. end
  401.  
  402. #==============================================================================
  403. # ** module DataManager
  404. #------------------------------------------------------------------------------
  405. #  For language loading
  406. #==============================================================================
  407. module DataManager
  408.   #--------------------------------------------------------------------------
  409.   # * alias
  410.   #--------------------------------------------------------------------------
  411.   class << self
  412.     alias h87loc_load_n_db load_normal_database
  413.     alias h87loc_load_b_db load_battle_test_database
  414.   end
  415.   # --------------------------------------------------------------------------
  416.   # * database loading
  417.   # --------------------------------------------------------------------------
  418.   def self.load_normal_database
  419.     h87loc_load_n_db
  420.     load_localization
  421.   end
  422.   # --------------------------------------------------------------------------
  423.   # * bt loading
  424.   # --------------------------------------------------------------------------
  425.   def self.load_battle_test_database
  426.     h87loc_load_b_db
  427.     load_localization if $data_localization.nil?
  428.   end
  429.   #--------------------------------------------------------------------------
  430.   # * language loading
  431.   #--------------------------------------------------------------------------
  432.   def self.load_localization
  433.     $data_localization = Data_Localization.new
  434.     $data_localization.load_language(H87Localization.selected_system_language)
  435.   end
  436. end
  437.  
  438. #==============================================================================
  439. # ** class Window_Base
  440. #------------------------------------------------------------------------------
  441. #  Changing method for advanced text drawing
  442. #==============================================================================
  443. class Window_Base < Window
  444.   alias h87loc_dte draw_text_ex unless $@
  445.   #--------------------------------------------------------------------------
  446.   # * draw_text_ex
  447.   #--------------------------------------------------------------------------
  448.   def draw_text_ex(x, y, text)
  449.     h87loc_dte(x, y, H87Localization.check_localized_string(text))
  450.   end
  451. end
  452.  
  453. #==============================================================================
  454. # ** class Game_Message
  455. #------------------------------------------------------------------------------
  456. #  Changing the text message
  457. #==============================================================================
  458. class Game_Message
  459.   alias h87loc_add add unless $@
  460.   #--------------------------------------------------------------------------
  461.   # * Add Text
  462.   #--------------------------------------------------------------------------
  463.   def add(text)
  464.     h87loc_add(H87Localization.check_localized_string(text))
  465.   end
  466. end
  467.  
  468. #==============================================================================
  469. # ** class Game_Interpreter
  470. #------------------------------------------------------------------------------
  471. #  Game Interpreter class
  472. #==============================================================================
  473. class Game_Interpreter
  474.   alias h87loc_setup_choices setup_choices unless $@
  475.   #--------------------------------------------------------------------------
  476.   # * Alias method for setup_choices, makes the choice window fit the text.
  477.   #--------------------------------------------------------------------------
  478.   def setup_choices(params)
  479.     par0 = params.clone
  480.     par0[0].map! {|text| H87Localization.check_localized_string(text) }
  481.     h87loc_setup_choices(par0)
  482.   end
  483. end
  484.  
  485. #==============================================================================
  486. # ** class Data_Localization
  487. #------------------------------------------------------------------------------
  488. #  Localization class for language and strings handling. Used in
  489. #  $data_localization instance.
  490. #==============================================================================
  491. class Data_Localization
  492.   #--------------------------------------------------------------------------
  493.   # * public instance variables
  494.   #--------------------------------------------------------------------------
  495.   attr_reader :lang_name
  496.   attr_accessor :language
  497.   #--------------------------------------------------------------------------
  498.   # * object initialization
  499.   #--------------------------------------------------------------------------
  500.   def initialize(lang = nil)
  501.     @strings = {}
  502.     load_language(lang, false) if lang
  503.   end
  504.   #--------------------------------------------------------------------------
  505.   # * language ID/code
  506.   #--------------------------------------------------------------------------
  507.   def lang_id
  508.     return @lang_id.to_i
  509.   end
  510.   #--------------------------------------------------------------------------
  511.   # * Checks if a game string contains a loalized string
  512.   #--------------------------------------------------------------------------
  513.   def parse_string(string)
  514.     H87Localization.check_localized_string(string)
  515.   end
  516.   #--------------------------------------------------------------------------
  517.   # * Takes a string from the loaded strings of the active language
  518.   #--------------------------------------------------------------------------
  519.   def get_string(string_id)
  520.     if @strings[string_id] != nil
  521.       return @strings[string_id].gsub(/\\n[^\[^<]/i,"\n")
  522.     else
  523.       println "String not found for value #{string_id}"
  524.       return string_from_other_languages(string_id, @language)
  525.     end
  526.   end
  527.   #--------------------------------------------------------------------------
  528.   # * Loads a new language
  529.   #   lang_name: language short name
  530.   #--------------------------------------------------------------------------
  531.   def load_language(lang_name, database = true)
  532.     @language = lang_name
  533.     file = H87Localization.language_file(lang_name)
  534.     unless File.exist?(file)
  535.       println "Language file #{file} not found."
  536.       return
  537.     end
  538.     File.open(file, "r") do |content|
  539.       @readstring = content.read
  540.     end
  541.     if language_ok?(@readstring)
  542.       load_database(@readstring) if $data_system && database
  543.       load_strings(@readstring)
  544.       println "Language loaded: #{file}."
  545.     else
  546.       println "Cannot read the #{file} file."
  547.       return
  548.     end
  549.   end
  550.   #--------------------------------------------------------------------------
  551.   # * Returns true if the file is a language file
  552.   #--------------------------------------------------------------------------
  553.   def language_ok?(readstring)
  554.     return false unless readstring =~ category_regexp("header")
  555.     info = string_array($1)
  556.     begin
  557.       @lang_name = info["Language"]
  558.       @lang_id = info["ID"]
  559.       return true
  560.     rescue
  561.       return false
  562.     end
  563.   end
  564.   #--------------------------------------------------------------------------
  565.   # * Load the localized database from file
  566.   #--------------------------------------------------------------------------
  567.   def load_database(readstring)
  568.     load_items(readstring)
  569.     load_skills(readstring)
  570.     load_weapons(readstring)
  571.     load_armors(readstring)
  572.     load_enemies(readstring)
  573.     load_actors(readstring)
  574.     load_classes(readstring)
  575.     load_states(readstring)
  576.     load_terms(readstring)
  577.   end
  578.   #--------------------------------------------------------------------------
  579.   # * Load items array
  580.   #--------------------------------------------------------------------------
  581.   def load_items(readstring)
  582.     item_list = load_data(readstring, "items",:id, :name, :description)
  583.     change_array($data_items, item_list)
  584.   end
  585.   #--------------------------------------------------------------------------
  586.   # * Load skills array
  587.   #--------------------------------------------------------------------------
  588.   def load_skills(readstring)
  589.     item_list = load_data(readstring, "skills",:id, :name, :description,
  590.     :message1, :message2)
  591.     change_array($data_skills, item_list)
  592.   end
  593.   #--------------------------------------------------------------------------
  594.   # * load weapons array
  595.   #--------------------------------------------------------------------------
  596.   def load_weapons(readstring)
  597.     item_list = load_data(readstring, "weapons",:id, :name, :description)
  598.     change_array($data_weapons, item_list)
  599.   end
  600.   #--------------------------------------------------------------------------
  601.   # * load armors array
  602.   #--------------------------------------------------------------------------
  603.   def load_armors(readstring)
  604.     item_list = load_data(readstring, "armors",:id, :name, :description)
  605.     change_array($data_armors, item_list)
  606.   end
  607.   #--------------------------------------------------------------------------
  608.   # * load enemies array
  609.   #--------------------------------------------------------------------------
  610.   def load_enemies(readstring)
  611.     item_list = load_data(readstring, "enemies",:id, :name)
  612.     change_array($data_enemies, item_list)
  613.   end
  614.   #--------------------------------------------------------------------------
  615.   # * load actors array
  616.   #--------------------------------------------------------------------------
  617.   def load_actors(readstring)
  618.     item_list = load_data(readstring, "actors",:id, :name, :title, :description)
  619.     change_array($data_actors, item_list)
  620.   end
  621.   #--------------------------------------------------------------------------
  622.   # * load class array
  623.   #--------------------------------------------------------------------------
  624.   def load_classes(readstring)
  625.     item_list = load_data(readstring, "classes",:id, :name)
  626.     change_array($data_classes, item_list)
  627.   end
  628.   #--------------------------------------------------------------------------
  629.   # * load states array
  630.   #--------------------------------------------------------------------------
  631.   def load_states(readstring)
  632.     item_list = load_data(readstring, "states",:id, :name, :message1, :message2,
  633.     :message3, :message4)
  634.     change_array($data_states, item_list)
  635.   end
  636.   #--------------------------------------------------------------------------
  637.   # * load terms array
  638.   #--------------------------------------------------------------------------
  639.   def load_terms(readstring)
  640.     terms = $data_system.terms
  641.     basic = get_string_array(readstring, "basic")
  642.     params = get_string_array(readstring, "params")
  643.     etypes = get_string_array(readstring, "etypes")
  644.     commands = get_string_array(readstring, "commands")
  645.     set_terms(terms.basic, basic)
  646.     set_terms(terms.params, params)
  647.     set_terms(terms.etypes, etypes)
  648.     set_terms(terms.commands, commands)
  649.   end
  650.   #--------------------------------------------------------------------------
  651.   # * Takes a substring from the file depending from the <type>...</type> tag
  652.   #--------------------------------------------------------------------------
  653.   def category_regexp(cat_name)
  654.     return /[.]*<#{cat_name}>(.*)<\/#{cat_name}>[.]*/im
  655.   end
  656.   #--------------------------------------------------------------------------
  657.   # * Load generic game strings
  658.   #--------------------------------------------------------------------------
  659.   def load_strings(readstring)
  660.     @strings = get_string_array(readstring, "strings")
  661.   end
  662.   #--------------------------------------------------------------------------
  663.   # * returns the string array
  664.   #   readstring: file readed
  665.   #   #header: string type
  666.   #--------------------------------------------------------------------------
  667.   def get_string_array(readstring, header)
  668.     if readstring =~ category_regexp(header)
  669.       return string_array($1)
  670.     end
  671.   end
  672.   #--------------------------------------------------------------------------
  673.   # * takes the proper string from file to array
  674.   #--------------------------------------------------------------------------
  675.   def set_terms(terms_array, term_hash)
  676.     return if term_hash.nil?
  677.     for i in 0..terms_array.size-1
  678.       next if term_hash[i.to_s].nil?
  679.       terms_array[i] = term_hash[i.to_s]
  680.     end
  681.   end
  682.   #--------------------------------------------------------------------------
  683.   # * strings array creation
  684.   #--------------------------------------------------------------------------
  685.   def string_array(text)
  686.     strings = {}
  687.     text.split(/[\r\n]+/).each do |string|
  688.       case string
  689.       when /[\s]*([^:.]*+)[\s]*:[\s]*(.+)[\s]*/i
  690.         key = $1
  691.         val = $2
  692.         key.gsub!(/[\t\n]/,""); val.gsub!(/[\t\n]/,"")
  693.         if strings[key].nil?
  694.           strings[key] = val
  695.         else
  696.           println "#{key} is defined twice!\n#{key}->#{strings[key]}\n#{$1}->#{val}"
  697.         end
  698.       end
  699.     end
  700.     return strings
  701.   end
  702.   #--------------------------------------------------------------------------
  703.   # * Return the regexp for taking a parameter
  704.   #--------------------------------------------------------------------------
  705.   def param_regexp
  706.     return /[\s]*(.+)[\s]*:(.+)[\s]*/i
  707.   end
  708.   #--------------------------------------------------------------------------
  709.   # * loads a data file to the system
  710.   #--------------------------------------------------------------------------
  711.   def load_data(*args)
  712.     readstring = args[0]
  713.     if readstring =~ category_regexp(args[1])
  714.       id = args[2]
  715.       text = $1
  716.       hash = {}
  717.       text.each_line do |line|
  718.         item = get_item_from_parameters(line)
  719.         next if item.empty? or item[id] == nil
  720.         idd = item[id].to_i
  721.         hash[idd] = {}
  722.         for i in 3..args.size-1
  723.           hash[idd][args[i]] = item[args[i]]
  724.         end
  725.       end
  726.     end
  727.     return hash
  728.   end
  729.   #--------------------------------------------------------------------------
  730.   # * Exchange the old array of the database from the new array
  731.   #--------------------------------------------------------------------------
  732.   def change_array(array, param_list)
  733.     return if param_list.nil?
  734.     param_list.each_pair do |key, params|
  735.       next if array[key].nil?
  736.       param_copy(array[key], params)
  737.     end
  738.   end
  739.   #--------------------------------------------------------------------------
  740.   # * Copy a parameter from the localized string to the old string
  741.   #   params: param array
  742.   #--------------------------------------------------------------------------
  743.   def param_copy(item, params)
  744.     params.each_pair do |param, value|
  745.       next if value.nil?
  746.       val = value.gsub("\\n","\n")
  747.       eval("item.#{param.to_s} = val")
  748.     end
  749.   end
  750.   #--------------------------------------------------------------------------
  751.   # * Gets a item from ID
  752.   #   line: ID
  753.   #--------------------------------------------------------------------------
  754.   def get_item_from_parameters(line)
  755.     item = {}
  756.     line.split(";").each do |param|
  757.       if param =~ param_regexp
  758.         key = $1; val = $2
  759.         key.gsub!(/[\t\n]/,""); val.gsub!(/[\t\n]/,"")
  760.         item[key.downcase.to_sym] = val
  761.       end
  762.     end
  763.     return item
  764.   end
  765.   #--------------------------------------------------------------------------
  766.   # * Dialet?
  767.   #   lang: language short name
  768.   #--------------------------------------------------------------------------
  769.   def dialet?(lang)
  770.     return H87Localization.dialet?(lang)
  771.   end
  772.   #--------------------------------------------------------------------------
  773.   # * Loads a string from another language.
  774.   #   string_id: string to load
  775.   #   language: current language
  776.   #--------------------------------------------------------------------------
  777.   def string_from_other_languages(string_id, language)
  778.     if H87Localization.dialet?(language)
  779.       traditional = H87Localization.base_language(language)
  780.       return string_from_other_languages(string_id, traditional)
  781.     elsif language != H87Localization.default_language
  782.       return get_language_string(string_id, H87Localization.default_language)
  783.     else
  784.       return "?#{string_id}?"
  785.     end
  786.   end
  787.   #--------------------------------------------------------------------------
  788.   # * Gets a string from another language and stores it
  789.   #--------------------------------------------------------------------------
  790.   def get_language_string(string_id, language)
  791.     dl = Data_Localization.new(language)
  792.     @strings[string_id] = dl.get_string(string_id)
  793.     return @strings[string_id]
  794.   end
  795. end
  796.  
  797. #--------------------------------------------------------------------------
  798. # * Command to add the language selection from Settings menu.
  799. #--------------------------------------------------------------------------
  800. if $imported["H87_Options"]
  801.   H87Options.push_system_option(H87Localization.create_option)
  802. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top