Game Updater System - ACE

%Q{
 ==============================================================================
  ■ Sistema di aggiornamenti di gioco di Holy87
      versione 1.2.02
      Difficoltà utente: ★★★★★
      Licenza: CC. Chiunque può scaricare, modificare, distribuire e utilizzare
      lo script nei propri progetti, sia amatoriali che commerciali. Vietata
      l'attribuzione impropria.

      Changelog versione 1.2.02
      ● Bugfix

      Changelog versione 1.2.01
      ● Il gioco non si blocca più quando si aprono le informazioni via web
        (niubba dimenticanza di riattivare la finestra, invece pensavo che si
        bloccasse il gioco)

      Changelog versione 1.2
      ● Il codice aftercode (vedi tutorial) viene eseguito al caricamento del
        gioco, non più alla schermata del titolo.
      ● Aggiunta compatibilità con le opzioni di gioco.

      Changelog versione 1.1
      ● Aggiunta compatibilità con menu titolo personalizzato.
      ● Aggiunta la possibilità di visualizzare l'aggiornamento prima di andare
        nella schermata del titolo, per renderlo compatibile con gli script come
        MogHunter
      ● Aggiunta la possibilità di riprodurre un suono se trova un aggiornamento.

  ■ Questo script serve a rilevare e scaricare gli aggiornamenti sul gioco.
    Quante volte ti sei accorto di aver fatto grossi errori solo dopo il
    rilascio del gioco completo? Anche se rilasci una versione aggiornata, non
    tutti i giocatori che l'hanno scaricato potrebbero averla o accorgersene.
    Ecco, con questo non avrai più problemi! Sarà il gioco stesso, all'avvio,
    a controllare la presenza di aggiornamenti e ad eventualmente scaricarli!
    L'unica cosa che tu dovrai fare, è configurare le informazioni sugli
    aggiornamenti.

  ■ Cose che puoi fare con gli aggiornamenti:
    ● Puoi obbligare l'utente ad aggiornare, altrimenti non può giocare
    ● Puoi inserire descrizioni sintetiche sull'aggiornamento: puoi usare
      anche tutti i caratteri speciali di formattazione, come cambio colore e
      dimensione del testo!
    ● Puoi visualizzare un'immagine (su internet o del gioco) come sfondo della
      schermata degli aggiornamenti
    ● Puoi aprire una pagina web per mostrare al giocatore maggiori dettagli
    ● Eseguire script configurati prima e dopo l'aggiornamento, al caricamento.
 ==============================================================================
  ■ Requisiti
    Essendo uno script complesso, richiede alcuni requisiti.
    ● Spazio FTP: Hai bisogno di uno spazio Web. Puoi registrarne uno in modo
      completamente gratuito su Altervista.
    ● Script Modulo Universale di Holy87, versione 1.6 o superiore.
    ● Script PHP per la WebAPI. Se non ce l'hai, puoi trovarlo qui
      http://www.mediafire.com/download/462x7vgpbdub00h/API_Server.zip
    ● Una certa esperienza con il patching. Non ti insegnerò a creare una patch.
 ==============================================================================
  ■ Compatibilità
    Scene_Title           -> alias start, create_command_window
    Window_TitleCommand   -> alias make_command_list
    * maggiori effetti se installato lo script Smooth_movement di Holy87
 ==============================================================================
  ■ Installazione
    Installare questo script sotto Materials e prima del Main.
 ==============================================================================
  ■ Istruzioni

  ▼ Configurazione dello script
    Lo script ha una configurazione di base per le stringhe e un'altra per
    configurare il tuo server remoto dove scaricare la patch.

    ● COSA IMPORTANTE, configura la variabile Domain (in basso) per l'indirizzo
      in cui si trova il file php del tuo spazio web.

    ● Creare nella cartella di gioco un file version.ini con all'interno la
      versione del gioco. La patch dovrà sovrascrivere anche questo file per
      aggiornare la versione di gioco. La versione di gioco può essere
      1.0, 1.2, 1.0.5, 1.2.3.2 ecc... a seconda dei cambiamenti.
      a.b.c.d
      a: Major release (un nuovo capitolo ad esempio, è quasi sempre 1)
      b: Minor release (espansione del gioco con nuovi elementi, nuove funzioni)
      c: Build (correzioni generiche al gioco, risoluzione di bug)
      d: Revisione (piccole modifiche leggere)

  ▼ Configurazione dell'aggiornamento

    ● La patch d'aggiornamento è un file da scaricare. Consiglio archivi o,
      meglio ancora, file d'installazione auto-configuranti. Puoi inserirla
      sul server stesso o su un altro spazio web remoto.

    ● Configura, nella cartella FTP dov'è situata la WebAPI, il file
      updateinfo.xml, che conterrà tutte le informazioni xml dell'aggiornamento
      nel caso esso sia presente. Puoi anche eliminarlo se non ci sono patch.

  ▼ Configurazione del file xml per la descrizione dell'aggiornamento
    Il file updateinfo.xml ha questa struttura:
      <?xml version='1.0' encoding='UTF-8'?>
      <update>
        <- qui ci va tutta la roba ->
      </update>
    Inserisci le seguenti tag tra i tag <update> e </update> per descrivere
    l'aggiornamento

    ● <version>x.x.x.x</version>
      Numero di versione dell'aggiornamento. Se è superiore alla versione del
      gioco, il gioco notificherà l'aggiornamento. Questo è un campo
      obbligatorio, se si omette non verrà notificato alcun aggiornamento.

    ● <filename>patch</filename>
      Nome del file della patch (ad es. Patch_1.05.zip)
      Puoi mettere solo il nome se si trova nella stessa cartella della WebAPI,
      altrimenti dovrai mettere l'indirizzo completo. Esempio
      http://downloadsite.com/Patch_1.05.zip
      Questo è un campo obbligatorio, se si omette potrebbe dare malfunzionamenti.

    ● <description>roba</description>
      Porta la descrizione che il giocatore andrà a vedere nella finestra
      d'aggiornamento, come le modifiche che apporterà. Puoi anche andare su
      più righe ed usare i caratteri speciali di RPG Maker per cambiare colore,
      grandezza ecc..., Esempio
      <description>Ciao Mondo!
      Questo è un \c[14]aggiornamento\c[0]
      Bello eh?</description>
      Questo non è un campo obbligatorio, ma è consigliato sempre metterlo per
      dare al giocatore un servizio migliore.

    ● <weblink>link</weblink>
      Link ad una pagina internet a discrezione dell'autore. Questa funzione è
      stata pensata per dare all'utente informazioni più dettagliate nel caso
      lo spazio per le descrizioni dell'aggiornamento sia troppo piccolo.
      Questo non è un campo obbligatorio.

    ● <image>nomeimmagine</image>
      Mostra un'immagine alternativa allo sfondo della schermata di aggiornamento
      Se è il nome di un'immagine (ad esempio sfondo.png) caricherà un'immagine
      nella cartella pictures del gioco. Se invece è un link a immagine (ad
      esempio http://www.miosito.com/immagine.jpg) lo script scaricherà l'immagine
      dal web e successivamente la applicherà come sfondo della schermata.
      Questo è un campo facoltativo.

    ● <forced>true</forced>
      Aggiungi questo campo se vuoi che l'aggiornamento sia forzato.
      L'aggiornamento forzato impedisce al gioco di avviare una nuova partita o
      di caricare il salvataggio se prima non aggiorna il gioco all'ultima
      versione. Questo campo è facoltativo, ma utile nel caso l'aggiornamento
      risolva un errore critico.

    ● <codexec>script</codexec>
      Aggiungi questo campo se vuoi che venga eseguito uno script prima di
      applicare la patch. Questa è una funzione per utenti pro e tutta
      facoltativa.

    ● <codeafter>script</codeafter>
      Aggiungi questo campo se venga eseguito uno script al caricamento del
      salvataggio precedente all'aggiornamento DOPO l'applicazione di
      una patch, ad esempio per aggiornare alcuni dati di gioco. Anche questa
      è una funzione facoltativa e per utenti pro.

  ▼ Creazione delle patch
    Non c'è molto da dire. L'essenziale è mettere in un archivio tutti i file
    del gioco che avete modificato. Ad esempio, se modificate un nemico
    create una cartella Data nell'archivio e inseriteci Enemies.rvdata2, se
    cambiate la WindowSkin create una cartella Graphics\Windows e inserite
    la windowskin. L'importante è rispettare i percorsi, in modo da permettere
    all'utente di fare direttamente copia dall'archivio e incolla nella cartella
    di gioco. Meglio se riuscite a fare una patch auto-installante, ma è troppo
    difficile da spiegare in questo script.
    Meglio se nell'archivio ci metti un file LEGGIMI.txt per indicare al
    giocatore cosa deve fare.
}
#==============================================================================
# ** CONFIGURAZIONE
#------------------------------------------------------------------------------
#  Puoi modificare le preferenze dello script qui
#==============================================================================
module H87Updater
  #--------------------------------------------------------------------------
  # * Configurazione di base
  #--------------------------------------------------------------------------
  #Inserisci in questo campo il link dov'è situata la tua WebAPI. Puoi usare
  #il dominio impostato nel modulo universale con H87_ModConfig::HTTPDOMAIN.
  Domain = H87_ModConfig::HTTPDOMAIN
  #Questo è il nome dello script PHP. Se non hai modificatoi l nome, lascialo
  #così com'è.
  WebAPI = "updateinfo.php"

  #--------------------------------------------------------------------------
  # * Stringhe: Queste sono le stringhe di base delle finestre
  #--------------------------------------------------------------------------
  #comando aggiorna nel titolo
  UPDATE_COMMAND = "Aggiorna"
  #testo mostrato nella finestra d'aiuto
  UPDATE_HELP = "Aggiorna il gioco all'ultima versione."
  #comando scarica nella schermata aggiornamenti
  UPDATE_START = "Scarica"
  #comando informazioni nella schermata aggiornamenti
  UPDATE_INFO = "Informazioni"
  #scritta delle dimensioni dell'aggiornamento
  UPDATE_SIZE = "Dimensioni: %10.2f kB"
  #scritta quando il download è in corso
  UPDATE_DOWNLOAD = "Download in corso... %d%%"
  #messaggio d'errore
  SIZE_ERROR = "Impossibile determinare la dimensione."
  #messaggio quando si entra nella schermata
  UPDATE_READY = "L'aggiornamento è pronto per essere scaricato."
  #messaggio quando si calcola la dimensione del file
  UPDATE_SCHK = "Ottengo le dimensioni del file..."
  #messaggio quando il download è completato
  DOWNLOAD_COMPLETED = "Download completato."
  #messaggio d'aiuto per avviare l'installazione
  DOWNLOAD_TIP = "Premi Invio per installare."
  #--------------------------------------------------------------------------
  # * Stringhe nel menu Opzioni - se hai installato lo script Opzioni di Holy
  #--------------------------------------------------------------------------
  OPT_TEXT = "Controllo aggiornamenti"
  OPT_HELP = "Attiva o disattiva il controllo degli aggiornamenti."
  OPT_ON   = "Attivato"
  OPT_OFF  = "Disattivato"
  #--------------------------------------------------------------------------
  # * Stringhe debug: queste stringhe servono per il debug, puoi ignorarle.
  #--------------------------------------------------------------------------
  DEBUG_CHECK = "Controllo aggiornamenti di gioco..."
  DEBUG_ERROR = "Impossibile connettersi al server per gli aggiornamenti."
  DEBUG_CODERROR = "Il codice non è stato eseguito per la seguente ragione:"
  DEBUG_DOWNLOAD = "Download da "
  DEBUG_COMP = "Download %s completato."
  DEBUG_VERS = "Versione attuale: %s"
  UPDATE_CURRENTV = "Ultima versione disponibile: "

  #--------------------------------------------------------------------------
  # * Colori della barra di download
  #--------------------------------------------------------------------------
  # NB: vengono presi i colori del testo della window
  #colore del primo gradiente
  GC1 = 28
  #colore del secondo gradiente
  GC2 = 29
  #suono che viene riprodotto all'avviso dell'aggiornamento. Metti "" se non
  #vuoi alcun suono.
  UpdateFX = "Chime2"
  #--------------------------------------------------------------------------
  # * Opzioni aggiuntive
  #--------------------------------------------------------------------------
  #imposta questo parametro su true se vuoi che lo sfondo delle finestre
  #sparisca quando c'è uno sfondo personalizzato. Falso altrimenti.
  WINDOWS_AUTOPACITY = true
  #Metti questa opzione a true se vuoi che il controllo degli aggiornamenti
  #venga proposto prima della schermata del titolo. Questa opzione è utile se
  #usi uno script per la schermata del titolo non compatibile con il sistema
  #d'aggiornamenti.
  PRETITLE_CHECK = false
  #richiesta d'aggiornamento nella schermata prima del titolo
  UPDATE_PRETITLE = "C'è un nuovo aggiornamento del gioco.
Vuoi aggiornare ora?"
  PRETITLE_YES = "Sì"
  PRETITLE_NOT = "No"
  #NEL CASO USI IL MENU TITOLO PERSONALIZZATO DI HOLY87
  #seleziona le immagini che verranno mostrate come comandi della schermata
  TITLE_ICON = "updater icon"
  TITLE_BALOON = "updater baloon"

#--------------------- FINE DELLA CONFIGURAZIONE ----------------------------











$imported = {} if $imported == nil
$imported["H87_Updater"] = 1.2
#==============================================================================
# ** H87Updater
#------------------------------------------------------------------------------
#  Modulo degli aggiornamenti
#==============================================================================
  #--------------------------------------------------------------------------
  # * Aggiornamento disponibile?
  #     true se c'è un aggiornamento disponibile
  #--------------------------------------------------------------------------
  def self.update_avaiable?
    return false if update_disabled?
    return @update_avaiable unless @update_avaiable.nil?
    println DEBUG_CHECK
    println sprintf(DEBUG_VERS, $game_system.game_version.to_s)
    begin
      update_version = get_update_version
    rescue UpdateCheckError
      println $!.message
      return false
    end
    @update_avaiable = $game_system.game_version < update_version
    println UPDATE_CURRENTV + update_version.to_s
    return @update_avaiable
  end
  #--------------------------------------------------------------------------
  # * Ottiene la versione dell'ultimo aggiornamento
  #--------------------------------------------------------------------------
  def self.get_update_version
    response = HTTP.await_get_server_response(Domain+"/"+WebAPI+"?get=version")
    unless HTTP.check_response(response)
      raise UpdateCheckError.new(DEBUG_ERROR)
    end
    version = Game_Version.new(response, 0)
    if version == "0.0.0.0"
      raise UpdateCheckError.new(response)
    end
    return version
  end
  #--------------------------------------------------------------------------
  # * Restituisce se l'aggiornamento è forzato
  #--------------------------------------------------------------------------
  def self.forced_update?
    if @forced.nil?
      response = HTTP.await_get_server_response(Domain+"/"+WebAPI+"?get=forced")
      unless HTTP.check_response(response)
        raise UpdateCheckError.new(DEBUG_ERROR)
      end
      @forced = response =~ /[.]*true[.]*/i
    end
    return @forced
  end
  #--------------------------------------------------------------------------
  # * Scarica le informazioni sull'aggiornamento e restituisce l'oggetto
  #     UpdateInfo
  #--------------------------------------------------------------------------
  def self.get_update_info
    response = HTTP.await_get_server_response(Domain+"/"+WebAPI+"?get=all")
    unless HTTP.check_response(response)
      raise UpdateInfoError.new(DEBUG_ERROR)
    end
    unless response =~ /[.]*|[.]*/
      raise UpdateCheckError.new(response)
    end
    return UpdateInfo.new(response)
  end
  #--------------------------------------------------------------------------
  # * Stesso metodo di update_avaiable?
  #--------------------------------------------------------------------------
  def self.new_update?
    return update_avaiable?
  end
  #--------------------------------------------------------------------------
  # * Crea e restituisce la cartella di download dei file
  #--------------------------------------------------------------------------
  def self.download_folder
    dir = "./Temp/"
    Dir.mkdir(dir) unless File.directory?(dir)
    dir
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se il controllo aggiornamento è disattivato dall'utente.
  #--------------------------------------------------------------------------
  def self.update_disabled?
    return false unless $imported["H87_Options"]
    return false if $game_settings["upd_opt"].nil?
    return !$game_settings["upd_opt"]
  end
  #--------------------------------------------------------------------------
  # * Inserimento del controllo nelle opzioni di gioco
  #--------------------------------------------------------------------------
  if $imported["H87_Options"]
    hash = {:type => :switch, :sw => "upd_opt", :text => OPT_TEXT,
            :help => OPT_HELP, :on => OPT_ON, :off => OPT_OFF, :default => true}
    H87Options.push_internet_option(hash)
  end
end

#==============================================================================
# ** UpdateCheckError e UpdateInfoError
#------------------------------------------------------------------------------
# Due classi che generano eccezioni
#==============================================================================
class UpdateCheckError < StandardError; end
class UpdateInfoError < StandardError; end

#==============================================================================
# ** UpdateInfo
#------------------------------------------------------------------------------
# Contiene le informazioni dell'aggiornamento
#==============================================================================
class UpdateInfo
  attr_reader :version            #numero di versione aggiornamento
  attr_reader :forced             #aggiornamento forzato?
  attr_reader :weblink            #link delle informazioni
  attr_reader :image              #immagine di sfondo dell'aggiornamento
  attr_reader :filename           #nome del file d'aggiornamento
  attr_reader :filelink           #link del file d'aggiornamento
  attr_reader :description        #descrizione dell'aggiornamento
  attr_reader :code_execution     #esecuzione del codice prima di aggiornare
  attr_reader :code_after_update  #esecuzione del codice al primo avvio dopo agg
  #--------------------------------------------------------------------------
  # * Inizializzazione
  #     update_string: stringa con le informazioni dell'agg. separate da |
  #--------------------------------------------------------------------------
  def initialize(update_string)
    info = update_string.split("|")
    @version = Game_Version.new(info[0])
    @forced = info[1] == "true" ? true : false
    @weblink = info[2].size > 0 ? info[2] : nil
    @image = info[3].size > 0 ? info[3] : nil
    @filelink = info[4]
    @filename = File.basename(@filelink)
    @description = info[5]
    @code_execution = info[6]
    @code_after_update = info[7]
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se è un'immagine locale
  #--------------------------------------------------------------------------
  def local_image?
    return false if @image.nil?
    return false if weblink?(@image)
    return true
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se c'è un link alla pagina delle informazioni
  #--------------------------------------------------------------------------
  def i_link?
    return @weblink != nil && @weblink != ""
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se la stringa è un link web
  #--------------------------------------------------------------------------
  def weblink?(link)
    return link  =~ /[ ]*http[s]?:\/\//i
  end
  #--------------------------------------------------------------------------
  # * Restuisce il link reale dove risiede la patch.
  #--------------------------------------------------------------------------
  def patch_truelink
    return @filelink if weblink?(@filelink)
    return H87Updater::Domain + "/" + @filelink
  end
end #updateinfo

#==============================================================================
# ** Vocab
#------------------------------------------------------------------------------
# Aggiunta dei vocaboli nuovi
#==============================================================================
module Vocab
  #--------------------------------------------------------------------------
  # * Vocabolo comando aggiorna
  #--------------------------------------------------------------------------
  def self.update
    H87Updater::UPDATE_COMMAND
  end
end #vocab

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
# Aggiunta dell'ultima versione del gioco presa dal salvataggio.
#==============================================================================
class Game_System
  alias h87updater_oal on_after_load unless $@
  #--------------------------------------------------------------------------
  # * Restuisce l'ultima versione del salvataggio
  #--------------------------------------------------------------------------
  def last_game_version
    update_version if @last_game_version.nil?
    return @last_game_version
  end
  #--------------------------------------------------------------------------
  # * Aggiorna la versione del salvataggio a quella attuale
  #--------------------------------------------------------------------------
  def update_version
    @last_game_version = $game_system.game_version
  end
  #--------------------------------------------------------------------------
  # * Alias del metodo per la fine del caricamento del salvataggio
  #--------------------------------------------------------------------------
  def on_after_load
    h87updater_oal
    check_aftercode
  end
  #--------------------------------------------------------------------------
  # * Controlla che il codice venga eseguito
  #--------------------------------------------------------------------------
  def check_aftercode
    return if last_game_version >= $game_system.game_version
    return if $game_settings[:aftercode].nil?
    $game_settings[:aftercode].each_pair do |version, code|
      next if version.nil?
      next if version == ""
      next if version <= last_game_version
      begin
        eval(code)
      rescue
        println H87Updater::DEBUG_CODERROR
        println $!.message
      end
    end
    update_version
  end
end #game_system

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
# Aggiunta del comando d'aggiornamento
#==============================================================================
class Scene_Title < Scene_Base
  alias h87updater_ccw create_command_window unless $@
  alias h87updater_stt start unless $@
  #--------------------------------------------------------------------------
  # * Alias metodo start
  #--------------------------------------------------------------------------
  def start
    flush_temp
    h87updater_stt
    #exec_aftercode > decommenta se vuoi che il codice venga eseguito qui
  end
  #--------------------------------------------------------------------------
  # * Creazione della finestra dei comandi
  #--------------------------------------------------------------------------
  def create_command_window
    h87updater_ccw
    @command_window.set_handler(:update, method(:command_update))
  end
  #--------------------------------------------------------------------------
  # * Azione del comando d'aggiornamento
  #--------------------------------------------------------------------------
  def command_update
    SceneManager.call(Scene_Updater)
  end
  #--------------------------------------------------------------------------
  # * Svuota la cartella temporanea
  #--------------------------------------------------------------------------
  def flush_temp
    Dir.foreach(H87Updater.download_folder) do |file|
      File.delete(H87Updater.download_folder+file) rescue next
    end
  end
  #--------------------------------------------------------------------------
  # * Esegue il codice quando l'aggiornamento ha avuto successo
  #--------------------------------------------------------------------------
  def exec_aftercode
    return if $game_settings[:aftercode].nil?
    return if $game_settings[:aftercode][$game_system.game_version.to_s].nil?
    return if $game_settings[:aftercode][$game_system.game_version.to_s] == ""
    begin
      eval($game_settings[:aftercode][$game_system.game_version.to_s])
    rescue
      println H87Updater::DEBUG_CODERROR
      println $!.message
    end
    $game_settings[:aftercode].delete($game_system.game_version.to_s)
    $game_settings.save
  end
  #--------------------------------------------------------------------------
  # * Aggiunta del comando del menu titolo personalizzato
  #--------------------------------------------------------------------------
  if $imported["H87_TitleMenu"]
  alias h87updater_ccp crea_contenuti_personalizzati
  def crea_contenuti_personalizzati
    h87updater_ccp
    if H87Updater.update_avaiable?
      add_cursor(:update,:command_update,H87Updater::TITLE_ICON,H87Updater::TITLE_BALOON)
    end
  end;end
end #scene_title

#==============================================================================
# ** Window_TitleCommand
#------------------------------------------------------------------------------
# Aggiunta del controllo e comando aggiornamento
#==============================================================================
class Window_TitleCommand < Window_Command
  alias h87updater_make_command_list  make_command_list unless $@
  #--------------------------------------------------------------------------
  # * Aggiunta del comando di aggiornamento (solo se è disponibile)
  #--------------------------------------------------------------------------
  def make_command_list
    if update_avaiable? && !H87Updater::PRETITLE_CHECK
      add_command(Vocab::update, :update)
      RPG::SE.new(H87Updater::UpdateFX).play
    end
    h87updater_make_command_list
    check_forced_update if update_avaiable?
  end
  #--------------------------------------------------------------------------
  # * Controllo dell'aggiornamento
  #--------------------------------------------------------------------------
  def update_avaiable?
    return H87Updater.new_update?
  end
  #--------------------------------------------------------------------------
  # * Controlla se l'aggiornamento è forzato e disabilita i comandi
  #--------------------------------------------------------------------------
  def check_forced_update
    return unless forced_update?
    @list.each do |command|
      if command[:symbol] == :new_game || command[:symbol] == :continue
        command[:enabled] = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se l'aggiornamento è forzato
  #--------------------------------------------------------------------------
  def forced_update?
    return H87Updater.forced_update?
  end
end #window_titlecommand

#==============================================================================
# ** Scene_Updater
#------------------------------------------------------------------------------
# La schermata dell'aggiornamento del gioco
#==============================================================================
class Scene_Updater < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Inizio
  #--------------------------------------------------------------------------
  def start
    super
    get_update_info                 #ottenimento delle informazioni
    create_help_window              #creazione della finestra d'aiuto
    create_command_window           #creazione della finestra comandi
    create_download_window          #creazione della finestra download
    create_info_window              #creazione della finestra informazioni
    check_wallpaper_background      #controllo dello sfondo personalizzato
  end
  #--------------------------------------------------------------------------
  # * Ottiene tutte le informazioni sull'aggiornamento
  #--------------------------------------------------------------------------
  def get_update_info
    @update_info = H87Updater.get_update_info
  end
  #--------------------------------------------------------------------------
  # * Crea la finestra d'aiuto
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_Help.new(1)

    @help_window.set_text(H87Updater::UPDATE_HELP)
  end
  #--------------------------------------------------------------------------
  # * Crea la finestra dei comandi
  #--------------------------------------------------------------------------
  def create_command_window
    y = @help_window.height
    @command_window = Window_UpdateCommand.new(0, y, @update_info.i_link?)
    @command_window.set_handler(:info, method(:launch_webInfo))
    @command_window.set_handler(:download, method(:patch_download))
    @command_window.set_handler(:cancel, method(:return_scene))
  end
  #--------------------------------------------------------------------------
  # * Crea la finestra di donwnload e info
  #--------------------------------------------------------------------------
  def create_download_window
    x = @command_window.width
    y = @command_window.y
    w = Graphics.width - x
    h = @command_window.height
    @download_window = Window_PatchDownload.new(x, y, w, h, @update_info)
  end
  #--------------------------------------------------------------------------
  # * Crea la finestra delle descrizioni dell'aggiornamento
  #--------------------------------------------------------------------------
  def create_info_window
    y = @command_window.y + @command_window.height
    w = Graphics.width
    h = Graphics.height - y
    @info_window = Window_UpdateInfo.new(0, y, w, h, @update_info.description)
  end
  #--------------------------------------------------------------------------
  # * Torna alla schermata precedente, o chiude il gioco se è forzato
  #--------------------------------------------------------------------------
  def return_scene
    unless H87Updater::PRETITLE_CHECK
      super
    else
      if H87Updater.forced_update?
        SceneManager.exit
      else
        SceneManager.goto(SceneManager.h87updater_first_scene_class)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Controlla se c'è uno sfondo del sistema d'aggiornamenti
  #--------------------------------------------------------------------------
  def check_wallpaper_background
    @background = Sprite.new
    @background.opacity = 0
    return if @update_info.image.nil?
    if @update_info.local_image?
      set_image_background(Cache.picture(@update_info.image))
    else
      println(H87Updater::DEBUG_DOWNLOAD + @update_info.image)
      folder = H87Updater.download_folder
      url = @update_info.image
      download_async(url, method(:image_downloaded), folder, false)
    end
  end
  #--------------------------------------------------------------------------
  # * Viene chiamato al download completato dell'immagine remota
  #--------------------------------------------------------------------------
  def image_downloaded
    imgname = File.basename(@update_info.image)
    println(sprintf(H87Updater::DEBUG_COMP, imgname))
    background_bitmap = Cache.load_bitmap(H87Updater.download_folder,imgname)
    set_image_background(background_bitmap)
  end
  #--------------------------------------------------------------------------
  # * Imposta lo sfondo della schermata
  #     bitmap: nuova bitmap
  #--------------------------------------------------------------------------
  def set_image_background(bitmap)
    @background.bitmap = bitmap
    @background.zoom_x = Graphics.width.to_f/@background.width.to_f
    @background.zoom_y = Graphics.height.to_f/@background.height.to_f
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento
  #--------------------------------------------------------------------------
  def update
    super
    update_background
    update_download_command
  end
  #--------------------------------------------------------------------------
  # * Fine
  #--------------------------------------------------------------------------
  def terminate
    super
    @background.dispose
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento dello sfondo
  #--------------------------------------------------------------------------
  def update_background
    return if @background.bitmap.nil?
    @background.opacity += 2
    if H87Updater::WINDOWS_AUTOPACITY
      @help_window.opacity -= 2
      @command_window.opacity -=2
      @info_window.opacity -= 2
      @download_window.opacity -= 2
    end
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento dei comandi dopo il download
  #--------------------------------------------------------------------------
  def update_download_command
    return unless @download_window.download_completed?
    return_scene if Input.trigger?(:B)
    start_patch if Input.trigger?(:C)
  end
  #--------------------------------------------------------------------------
  # * Lancia il sito delle informazioni sul browser
  #--------------------------------------------------------------------------
  def launch_webInfo
    Sound.play_ok
    Browser.open(@update_info.weblink)
    @command_window.activate
  end
  #--------------------------------------------------------------------------
  # * Scarica la patch
  #--------------------------------------------------------------------------
  def patch_download
    @download_window.width = Graphics.width
    if $imported["H87_SmoothMovements"]
      @command_window.smooth_move(0-@command_window.width, @command_window.y)
      @download_window.smooth_move(0, @download_window.y)
    else
      @command_window.visible = false
      @download_window.x = 0
    end
    @download_window.download_start
  end
  #--------------------------------------------------------------------------
  # * Esegue la patch scaricata
  #--------------------------------------------------------------------------
  def start_patch
    exec_code
    register_aftercode
    exec_patch
    sleep(0.1)
    close_game
  end
  #--------------------------------------------------------------------------
  # * Esegue il codice personalizzato (se presente)
  #--------------------------------------------------------------------------
  def exec_code
    return if @update_info.code_execution.nil?
    return if @update_info.code_execution == ""
    begin
      eval(@update_info.code_execution)
    rescue
      println H87Updater::DEBUG_CODERROR
      println $!.message
    end
  end
  #--------------------------------------------------------------------------
  # * Registra il codice personalizzato dopo la patch
  #--------------------------------------------------------------------------
  def register_aftercode
    code = @update_info.code_after_update
    $game_settings[:aftercode] = {} if $game_settings[:aftercode].nil?
    $game_settings[:aftercode][@update_info.version.to_s] = code
    $game_settings.save
  end
  #--------------------------------------------------------------------------
  # * Apre la patch scaricata
  #--------------------------------------------------------------------------
  def exec_patch
    path = File.expand_path(H87Updater.download_folder)
    file = sprintf("explorer %s/%s", path, @update_info.filename)
    Thread.new{system(file.gsub("/","\\"))}
  end
  #--------------------------------------------------------------------------
  # * Chiude il gioco
  #--------------------------------------------------------------------------
  def close_game
    SceneManager.exit
  end
end #scene_update

#==============================================================================
# ** Window_UpdateCommand
#------------------------------------------------------------------------------
# Finestra dei comandi della schermata di aggiornamento
#==============================================================================
class Window_UpdateCommand < Window_Command
  #--------------------------------------------------------------------------
  # * Inizializzazione
  #     x: coordinata X
  #     y: coordinata Y
  #     info: informazione attivata?
  #--------------------------------------------------------------------------
  def initialize(x, y, info)
    @info_enabled = info
    super(x, y)
  end
  #--------------------------------------------------------------------------
  # * Genera la lista dei comandi
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(H87Updater::UPDATE_START, :download)
    add_command(H87Updater::UPDATE_INFO, :info, @info_enabled)
  end
end
#==============================================================================
# ** Window_PatchDownload
#------------------------------------------------------------------------------
# Finestra di download della patch (e dettagli)
#==============================================================================
class Window_PatchDownload < Window_Base
  #--------------------------------------------------------------------------
  # * Inizializzazione
  #     x: coordinata X
  #     y: coordinata Y
  #     w: larghezza
  #     h: altezza
  #     info: oggetto Updater_Info con la descrizione dell'aggiornamento
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h, info)
    super(x, y, w, h)
    @info = info
    @state = 0
    refresh
    check_download_size
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    case @state
    when 0
      create_initial_content
    when 1
      draw_download_state
    when 2
      draw_final_text
    end
  end
  #--------------------------------------------------------------------------
  # * Aggiornamento
  #--------------------------------------------------------------------------
  def update
    super
    refresh if downloading?
  end
  #--------------------------------------------------------------------------
  # * Controlla le dimensioni della patch
  #--------------------------------------------------------------------------
  def check_download_size
    if @info.weblink?(@info.filelink)
      sizeloaded(HTTP.get_file_size(@info.patch_truelink))
    else
      url = H87Updater::Domain+"/"+H87Updater::WebAPI+"?get=size"
      get_response_async(url, method(:sizeloaded))
    end
  end
  #--------------------------------------------------------------------------
  # * Crea il contenuto iniziale
  #--------------------------------------------------------------------------
  def create_initial_content
    change_color(power_down_color)
    draw_text(line_rect(0), $game_system.game_version)
    change_color(power_up_color)
    draw_text(line_rect(0), @info.version, 2)
    change_color(normal_color)
    draw_text(line_rect(0), "->", 1)
    draw_text(0, ln(1), contents_width, line_height, H87Updater::UPDATE_SCHK)
  end
  #--------------------------------------------------------------------------
  # * Inizia il download
  #--------------------------------------------------------------------------
  def download_start
    create_contents
    @state = 1
    @old_perc = 0
    folder = H87Updater.download_folder
    url = @info.patch_truelink
    download_async(url, method(:download_complete), folder, false)
  end
  #--------------------------------------------------------------------------
  # * Disegna lo stato del download
  #--------------------------------------------------------------------------
  def draw_download_state
    progress = download_status(@info.filename)
    return if progress.to_i == @old_perc
    clear_line(0)
    text = sprintf(H87Updater::UPDATE_DOWNLOAD, progress)
    draw_text(line_rect(0), text)
    rect = line_rect(1)
    draw_gauge(rect.x, rect.y, rect.width, progress/100.0, gauge1, gauge2)
    @old_perc = progress.to_i
  end
  #--------------------------------------------------------------------------
  # * Download completato
  #--------------------------------------------------------------------------
  def download_complete
    @state = 2
    refresh
  end
  #--------------------------------------------------------------------------
  # * Disegna il testo di download completato
  #--------------------------------------------------------------------------
  def draw_final_text
    contents.clear
    draw_text(line_rect(0),H87Updater::DOWNLOAD_COMPLETED)
    draw_text(line_rect(1),H87Updater::DOWNLOAD_TIP)
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se sta scaricando
  #--------------------------------------------------------------------------
  def downloading?
    @state == 1
  end
  #--------------------------------------------------------------------------
  # * Restituisce true se il download è completato
  #--------------------------------------------------------------------------
  def download_completed?
    @state == 2
  end
  #--------------------------------------------------------------------------
  # * Restituisce la coordinata y della linea
  #--------------------------------------------------------------------------
  def ln(number)
    line_height*number
  end
  #--------------------------------------------------------------------------
  # * Viene chiamato quando si ottiene la dimensione del file
  #     value: dimensione del file
  #--------------------------------------------------------------------------
  def sizeloaded(value)
    return if @downloaded
    clear_line(1)
    begin
      value = value.to_i
      text = sprintf(H87Updater::UPDATE_SIZE, value/1000.0)
    rescue
      text = sprintf(H87Updater::SIZE_ERROR)
    end
    draw_text(0,ln(1),contents_width,line_height, text)
  end
  #--------------------------------------------------------------------------
  # * Ottiene il rettangolo della linea
  #--------------------------------------------------------------------------
  def line_rect(line)
    Rect.new(0, line_height*line, contents_width, line_height)
  end
  #--------------------------------------------------------------------------
  # * Pulisce la linea
  #--------------------------------------------------------------------------
  def clear_line(line)
    contents.clear_rect(line_rect(line))
  end
  #--------------------------------------------------------------------------
  # * Restituisce i colori della barra
  #--------------------------------------------------------------------------
  def gauge1; text_color(H87Updater::GC1); end
  def gauge2; text_color(H87Updater::GC2); end
end #window_info

#==============================================================================
# ** Window_UpdateInfo
#------------------------------------------------------------------------------
# Finestra che mostra la descrizione dell'aggiornamento
#==============================================================================
class Window_UpdateInfo < Window_Base
  #--------------------------------------------------------------------------
  # * Iniaizlizzazione
  #     text: testo di descrizione
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h, text)
    super(x, y, w, h)
    @text = text
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    draw_text_ex(4, 0, @text.gsub(" ",""))
  end
end

#==============================================================================
# ** SceneManager
#------------------------------------------------------------------------------
# Cambio della prima schermata
#==============================================================================
module SceneManager
  class << self
    alias h87updater_first_scene_class first_scene_class
  end
  #--------------------------------------------------------------------------
  # * Cambio della prima schermata
  #--------------------------------------------------------------------------
  def self.first_scene_class
    return h87updater_first_scene_class unless H87Updater::PRETITLE_CHECK
    return h87updater_first_scene_class if @update_checked
    return h87updater_first_scene_class unless H87Updater.update_avaiable?
    @update_checked = true
    return Scene_UpdateCheck
  end
end #scenemanager

#==============================================================================
# ** Scene_UpdateCheck
#------------------------------------------------------------------------------
# Schermata di richiesta d'aggiornamento prima della schermata del titolo
#==============================================================================
class Scene_UpdateCheck < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Inizio
  #--------------------------------------------------------------------------
  def start
    super
    create_help_window
    create_command_window
  end
  #--------------------------------------------------------------------------
  # * Creazione della finestra d'aiuto
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_Help.new
    @help_window.set_text(H87Updater::UPDATE_PRETITLE)
  end
  #--------------------------------------------------------------------------
  # * Creazione della finestra dei comandi
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_UpdateRequest.new(@help_window.height)
    @command_window.set_handler(:yes, method(:update_scene))
    @command_window.set_handler(:no, method(:normal_scene))
    @command_window.set_handler(:back, method(:normal_scene))
  end
  #--------------------------------------------------------------------------
  # * Porta alla schermata d'aggiornamento
  #--------------------------------------------------------------------------
  def update_scene
    SceneManager.goto(Scene_Updater)
  end
  #--------------------------------------------------------------------------
  # * Porta alla schermata iniziale
  #--------------------------------------------------------------------------
  def normal_scene
    if H87Updater.forced_update?
      SceneManager.exit
    else
      SceneManager.goto(SceneManager.h87updater_first_scene_class)
    end
  end
end #updatecheck

#==============================================================================
# ** Window_UpdateRequest
#------------------------------------------------------------------------------
# Finestra dei comandi che mostrano sì o no.
#==============================================================================
class Window_UpdateRequest < Window_Command
  #--------------------------------------------------------------------------
  # * Inizializzazione
  #     y: coordinata Y
  #--------------------------------------------------------------------------
  def initialize(y)
    super(0, y)
    self.x = Graphics.width - self.width
  end
  #--------------------------------------------------------------------------
  # * Creazione della lista dei comandi
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(H87Updater::PRETITLE_YES, :yes)
    add_command(H87Updater::PRETITLE_NOT, :no)
  end
end #fine dello script