Game Updater System v2 (Nuovo!!)

[Holy87]

Vi è mai capitato di rilasciare un progetto sia completo che demo, e poi accorgervi di aver tralasciato qualche dettaglio, o di non aver fixato qualche bug prima di distribuirlo al grande pubblico?

Ovviamente molti diranno di sì, e che spesso rilasciare una piccola patch è sì possibile, ma non tutti coloro che scaricheranno il gioco potranno sempre sapere se avete rilasciato un fix e tantomeno poterla scaricare, rendendo il rilascio di pezze quasi inutile.

E vi è mai capitato di voler aggiungere contenuti aggiuntivi, come nuovi oggetti o nuove mappe, e volerlo distribuire a tutti in un colpo solo?

 

E se invece voi rilasciaste una patch su Internet e sia il gioco, una volta avviato, che controlla al posto del giocatore se sono stati rilasciati aggiornamenti, e magari a scaricarli e installarli?

 

È proprio questa la mia idea (dato che spesso sono distratto), e proprio per questo ho creato questo script!

Game Updater v2.1

Descrizione

Scarica automaticamente patch per correggere gli errori del gioco. Se non è stata rilasciata alcuna patch o non riesce a connettersi a internet, non apparirà nessun avviso nè menu di aggiornamento, in poche parole, se non viene rilasciato alcun aggiornamento, il giocatore non saprà nemmeno che questa feature esiste

Sarà possibile anche far si che selezionando "maggiori informazioni", verrà aperta una pagina del browser indirizzata a un sito da voi specificato (ad esempio, la pagina contenente i cambiamenti dell'aggiornamento).

Altrimenti, sarà possibile inserire direttamente le informazioni dell'aggiornamento nel momento nell'apposita schermata, quando il ciocatore dovrà far partire il download.

È anche possibile obbligare il giocatore ad aggiornare il gioco, per poter giocare!

Una volta scaricato, verrà aperto il file se è un archivio, o eseguito se è un exe. Il gioco si chiuderà automaticamente per consentire al giocatore di applicare la patch.

Questa nuova versione, oltre ad avere nuove funzionalità, è più stabile, più modulare e più affidabile.

Autore

Holy87

Difficoltà

Esperto

Allegati

Demo dello script: Download qui

Suggerimento: Per vedere come funziona nel caso non disponiate di uno spazio web, settate quest'url di prova nello script:

http://holyres.alter....org/updateinfo

 

Documentazione dettagliata sullo script: qui (vecchia versione)

per capire come funziona e come usarlo al meglio

 

Potete usare una di queste immagini come popup che viene visualizzato nella schermata del titolo:

Le immagini vanno inserite in Graphics\System.

http://img853.imageshack.us/img853/3765/adviceu.png

http://img24.imageshack.us/img24/3741/advice3.png

Se non intendete usare un popup, impostate "ACTIVATE_POPUP" su false

Istruzioni per l'uso

Requisiti fondamentali:

• Avere una certa esperienza in patching (sapere quali file verranno aggiornati!)
• Possedere un FTP, uno spazio web o un servizio che offra download diretti a tutti
• Installare lo script di Berka per internet nel progetto
• Non necessario, ma consiglierei di non criptare il gioco, in modo da poter sostituire pochi file e non tutto l'RGSSAD2.

Inserite lo script Updater e il modulo di Berka sotto Materials e prima del Main.

 

Create una patch, che sia un exe autoestraente, un file zip, rar o quello che sia e uppatelo online.

Create un file di testo, potete chiamarlo come volete e metterci l'estenione che volete (.txt, .ini, .cacca, o niente)

In questo file di testo dovrete inserire le informazioni dell'aggiornamento tramite TAG (non importa l'ordine):

[V]1.02
[L]http://mysite.com/patch.zip
http://www.mysite.com/changelog.htm

Con la tag [V] bisogna specificare il numero di versione che avrà l'aggiornamento. Se il gioco ad esempio è alla versione 1.0, lo script confronterà la versione con 1.02, vedrà che c'è una versione più aggiornata e avviserà il giocatore.

Con la tag [L] invece dovrà essere inserito il link diretto per scaricare la patch.

Non è finita qui!

È possibile inserire opzionalmente maggiori opzioni e informazioni:

• [P] a inizio della riga vi permetterà di inserire un'immagine di sfondo personalizzata nella schermata di download, ad esempio per mostrare un' "anteprima" dell'aggiornamento. Puoi scrivere il nome del file presente nella cartella Pictures del gioco, oppure inserire un link diretto all'immagine, nel caso in cui questa non sia presente nel gioco.
• a inizio riga vi permetterà di inserire un collegamento ad un sito per ottenere maggiori informazioni: se inserito, comparirà un nuovo comando nella schermata di aggiornamento che farà aprire il browser all'indirizzo specificato.
• [F] forzerà il giocatore ad aggiornare, altrimenti non potrà giocare la sua partita.
• [O] aprirà la cartella del gioco al termine dello scaricamento della patch. Utile nel caso in cui l'aggiornamento risieda in un file zip, dove il giocatore dovrà manualmente trascinare i file nella cartella del gioco.
• # è un commento, una riga che comincia con il cancelletto non verrà letta.
• Una riga senza nessun altro tag precedente è da considerarsi una descrizione dell'aggiornamento. È possibile in questo caso usare il tag B per far apparire dei pallini per elencare delle feature.

Esempio, iseriamo nel file info questo testo:

[V]1.02
[L]http://miosito.com/Patch.zip
[F]
[O]
[P]http://www.rpg2s.net/forum/public/style_images/3_banneragosto.png
[i]http://www.rpg2s.net/forum/index.php?showtopic=14196
#queste sono le informazioni:
Informazioni sull'aggiornamento:
L'aggiornamento presenta i seguenti bugfix:
[b]Risolto il crash del gioco all'uscita
[b]Ora la missione "Vendita dei meloni" si può completare
[b]Adesso il gioco non si blocca più se si entra dal fruttivendolo.
Inoltre, sono state aggiunte le seguenti novità:
[b]Nuova spada leggendaria acquistabile dal mercante segreto
[b]Nuovo labirinto vicino alle montagne
[b]Nuovi mostri.

Ecco il risultato:

http://img259.imageshack.us/img259/766/screenshotetl.png

 

ATTENZIONE: Il file Script.rvdata dev'essere sempre compreso nella patch e deve avere il numero di versione del gioco aggiornato (uguale a quello della patch), altrimenti il gioco continuerà ad avvisare il giocatore degli aggiornamenti anche dopo aver applicato la patch.

 

Istruzioni più dettagliate le trovate all'interno dello script.

 

Script:

 

$imported = {} if $imported == nil
$imported["H87_Updater"] = true
=begin
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
                          * GAME UPDATER SYSTEM *
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
  Versione 2.2
  ------------------------------------------------------------------------------
  Novità sulla versione:
  ● Molto più preciso nel rilevare nuovi aggiornamenti
  ● Molte più funzionalità
  ● Molto più elegante
  ● Molto più personalizzabile
  ● Molto più stabile
  ● Molti meno errori
  ● Molto più modulare
  ● Molto più figo.
  Ora è possibile non solo inserire una descrizione dettagliata dell'aggiorna-
  mento direttamente nel file delle informazioni, ma è anche possibile cambiare
  sfondo a piacimento. Il movimento della barra di download è più fluido e il
  suo aspetto è personalizzabile.
  ------------------------------------------------------------------------------
  Lo script cercherà aggiornamenti all'avvio del gioco, e avviserà il giocatore
  nel caso ci sia una patch disponibile. Il giocatore quindi potrà andare nella
  schermata di download per scaricare ed installare la patch. A differenza della
  vecchia versione, le informazioni sull'aggiornamento contengono molte più
  informazioni, a seconda del tipo e delle preferenze del programmatore in quel
  momento.
  Nel caso non ci fosse nessun aggiornamento, l'opzione di aggiornamento verrà
  nascosta.
  ------------------------------------------------------------------------------
  Installazione:
  Incollare lo script sotto Materials e prima del Main, SOPRA lo script del
  Menu Titolo personalizzato (se presente). Necessita il modulo di Berka.
  ------------------------------------------------------------------------------
  Istruzioni per l'uso:
  Carica la patch su internet, preferibilmente su un link diretto.
  Crea un file di testo (ma puoi darci l'estensione che vuoi) e inserisci
  le seguenti tag all'interno all'inizio di ogni riga (non importa l'ordine):
  ||[V]<numeroversione>
  Questo ovviamente è obbligatorio, altrimenti non verrà visto alcun
  aggiornamento. Inserisci il numero di versione dell'aggiornamento, ad esempio
  ||[V]1.5
  
  ||[L]<link_patch>
  anche questo è obbligatorio, devi inserire il link diretto dove scaricare la
  patch, altrimenti non scaricherà nulla e il giocatore non potrà aggiornare. Es
  ||[L]http://www.miosito.it/Patch.zip (non dimenticare "http://"!)
  
  ||[i]<link_sito>
  Facoltativo, se viene inserito verrà mostrata nella schermata, l'opzione per
  andare sul sito specificato nel link, aprendo il browser a quella pagina. Es.
  ||[i]http://www.rpg2s.net
  
  ||[F]
  Facoltativo, se inserisci questo tag il giocatore sarà forzato ad aggiornare,
  e non potrà giocare se non aggiornerà il gioco. Utile per aggiornamenti
  critici.
  
  ||[O]
  Facoltativo, se inserisci questo tag, una volta scaricato l'aggiornamento
  verrà aperta anche la cartella dove risiede il gioco, utile per permettere
  al giocatore di trasferire manualmente la cartella della patch dal file zip
  alla cartella del gioco trascinandola.
  
  ||[P]<nome o url_immagine>
  Facoltativo, permette di impostare un'immagine di sfondo nella schermata
  diversa da quella predefinita, ad esempio per presentare la patch con nuove
  funzionalità. L'immagine verrà automaticamente stretchata per occupare lo
  schermo. Esempio:
  ||[P]Sfondo1
  Verrà usato come sfondo della schermata di aggiornamento l'immagine nella
  cartella Graphics\Pictures\Sfondo1. Altrimenti:
  ||[P]http://www.miosito.it/Sfondo2.jpg
  Verrà scaricata immediatamente l'immagine Sfondo2.jpg ed usata come sfondo
  della schermata. In questo caso è consigliato usare immagini non troppo
  pesanti, per evitare che il giocatore debba aspettare troppo tempo per
  caricare la schermata.
  
  Qualsiasi altra riga senza etichetta, verrà considerata una descrizione dell'
  aggiornamento, e potrai usare l'etichetta [b] per mostrare un pallino, utile
  per elencare le novità. Ad esempio:
  
  ||Informazioni sull'aggiornamento:
  ||Questo aggiornamento risolve vari bug e
  ||implementa le seguenti novità:
  ||[b]Drop incrementati
  ||[b]Nuove armi
  ||[b]Nuovi oggetti
  ||[b]Nuove città
  
  NOTA: LA PATCH DEVE CONTENERE ANCHE IL FILE DATA\SCRIPTS.RVDATA CON IL NUMERO
  DI VERSIONE AGGIORNATO: ALTRIMENTI CONTINUERA' A CHIEDERE L'AGGIORNAMENTO
  ANCHE QUANDO IL GIOCO SARA' AGGIORNATO.
  È importante che ogni etichetta cominci con ||.
  
  Maggiori personalizzazioni le troverai nella sezione Impostazioni.
  ------------------------------------------------------------------------------
  Compatibilità:
  Compatibile con la maggior parte degli script. Modifica la classe Scene_Title,
  alias dei seguenti metodi:
  start, update, terminate, create_command_window, command_continue,
  command_new_game.
=end
module Updater
  module Settings
    #===========================================================================
    # ** IMPOSTAZIONI **
    #===========================================================================
    #
    # * Impostazioni principali:
    #---------------------------------------------------------------------------
    #Imposta la versione attuale del gioco:
    Game_Version = 1.0
    #
    #Imposta l'URL dove scaricare il file contenente le informazioni
    Info_URL = "http://miosito.com/info.txt"
    #---------------------------------------------------------------------------
    #
    # * Personalizzazioni:
    #---------------------------------------------------------------------------
    # * Immagini:
    #Vuoi usare un'immagine di sfondo specifica?
    Usa_Immagine = false #true se la vuoi usare
    #Nota: nel caso sia specificata un'altra immagine nelle informazioni sull'
    #aggiornamento, verrà usata quella.
    #
    #Scegli l'immagine per lo sfondo della schermata.
    #L'immagine va messa nella cartella Graphics\Pictures
    Immagine = ""
    #
    #Vuoi che l'immagine di sfondo venga sfuocata? (se c'è)
    Sfuoca_Sfondo = false #false altrimenti
    #
    #Vuoi usare una immagine di popup per l'aggiornamento?
    Attiva_Popup = true
    #Seleziona l'immagine nella cartella Graphics\Pictures
    Popup_Immagine = "adviceu"
    #
    #Aspetto della barra di download:
    #0: Monocromatico, 1: Gradiente, 2: Rilievo
    Aspetto = 0
    #Colore della barra di download:
    Colore = [
    50,   #Rosso
    210,  #Verde
    10    #Blu
    ]
    #
    # Regola l'opacità delle finestre, nel caso voglia renderle trasparenti
    # oppure no: (valore da 0 a 255)
    Opacita = 0
    #
    # * Effetti Sonori:
    #Suono quando c'è un nuovo aggiornamento:
    Suono_Popup = "Chime1"
    #Suono quando il download è cominciato:
    Suono_Iniziato = "Flash2"
    #Suono quando il download è completato:
    Suono_Completato = "Chime1"
    #
    # * Stringhe:
    #Imposta le stringhe da usare nel testo
    T_Menu = "Aggiornamento"              #Nella schermata del titolo
    T_Popp = "Devi aggiornare il gioco per poter giocare!" #obbliga ad aggiornare
    T_Aggu = "Aggiornamento alla versione %.2f." #Mostra la versione da installare
    T_Aggd = "Versione installata: %.2f."         #Mostra la versione installata
    T_DinC = "Download in corso... %d%"         #Mostra la % completata
    T_Comp = "Download completato."             #Viene mostrato a download com.
    T_Camb = "Novità:"                          #Descrizione delle novità
    TM_Sca = "Scaria ora"           #Menu di selezione per scaricare
    TM_Esc = "Torna al titolo"      #Menu di selezione per uscire
    TM_Inf = "Maggiori Informazioni"#Viene mostrato se c'è un url nel testo
    T_Agg3 = "File salvato in %s."  #Mostra il percorso di salvataggio
    T_Agg4 = "Premi Azione per installare."     #Viene mostrato per download comp.
    T_Errr = "C'è stato un errore. Non ho potuto scaricare l'aggiornamento."
    
    #===========================================================================
    # * ATTENZIONE: NON MODIFICARE AL DI SOTTO DI QUESTA RIGA SE NON SAI CIO'
    # CHE FAI, POTRESTI COMPROMETTERE L'INTERO FUNZIONAMENTO DELLO SCRIPT
    #===========================================================================
    
    
    
    
  end # Settings
  
  include Settings
  #--------------------------------------------------------------------------
  # * Controlla se è disponibile un aggiornamento e restituisce true o false
  #--------------------------------------------------------------------------
  def self.update_avaiable?
    if @update_disponibile != nil
      return @update_disponibile
    else
      scarica_file_info
      return true if versione_disponibile > versione_attuale
      return false
    end
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il nome del file info
  #--------------------------------------------------------------------------
  def self.nome_file_info
    return File::basename(Settings::Info_URL)
  end
  
  # -------------------------------------------------------------------------- 
  # Converte i percorsi Ruby (con /) in percorsi Windows UNC (con \)
  # --------------------------------------------------------------------------
  def self.converti_UNC(path)
    return path.gsub("/","\\")
  end
  
  #--------------------------------------------------------------------------
  # * Inizializza le variabili
  #--------------------------------------------------------------------------
  def self.inizializza_variabili
    @versione = 0
    @forza = false
    @descrizione = []
    @url_sito = nil
    @update_disponibile = nil
    @nomeimmagine = nil
    @url_patch = ""
    @apertura = false
  end
  
  #--------------------------------------------------------------------------
  # * Scarica il file delle informazioni
  #--------------------------------------------------------------------------
  def self.scarica_file_info
    inizializza_variabili
    refresh_file(nome_file_info) if versione_windows >= 6
    Net::HTTP.download(Info_URL,"./")
    loop {break if Net::HTTP.loaded?(nome_file_info)}
    @update_disponibile = false unless file_buono?(nome_file_info)
    elabora_file_info
  end
  
  #--------------------------------------------------------------------------
  # * Controlla se il file scaricato è buono e restituisce true o false
  #--------------------------------------------------------------------------
  def self.file_buono?(nomefile)
    if File.exist? (nomefile) #apre il file in sola lett.
      File.open(nomefile,"r") do |f|
      f.lineno = 1 # imposta la riga n.1
      txt = f.gets
      return false if txt == "" or txt == nil
      @controllore = txt[0].chr
      return false if @controllore == "" or @controllore == nil
      end
    else
      return false
    end
    return false if @controllore == "<"
    return true
  end
  
  #--------------------------------------------------------------------------
  # * Elabora il file delle informazioni scaricato e le memorizza
  #--------------------------------------------------------------------------
  def self.elabora_file_info
    return unless file_buono?(nome_file_info)
    file = File.open(nome_file_info,"r") #apre il file in lettura
    stringa = ""
    file.each_line do |l|
      #next if l[0].chr == "#"
      stringa = stringa + l
    end
    stringa = stringa.split("||")
    for i in 0..stringa.size-1
      linea = stringa[i].gsub("\n","")
      case linea[0..2] #per sicurezza, converto in maiuscole
      when "[V]" #tag numero di versione
        @versione = linea.gsub("[V]","").to_f
        next
      when "[L]" #tag link della patch
        @url_patch = linea.gsub("[L]","")
        next
      when "[F]" #tag aggiornamento forzato?
        @forza = true
        next
      when "[i]" #tag link informazione
        @url_sito = linea.gsub("[i]","")
        next
      when "[P]" #tag immagine
        @nomeimmagine = linea.gsub("[P]","")
        next
      when "[O]" #tag apertura cartella
        @apertura = true
        next
      end #altrimenti, aggiunge una riga alla descrizione:
      @descrizione.push(linea)
    end
    file.close #chiude il file
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce la versione dell'aggiornamento
  #--------------------------------------------------------------------------
  def self.versione_disponibile
    return @versione
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce la versione attuale del gioco
  #--------------------------------------------------------------------------
  def self.versione_attuale
    return Game_Version
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce true se è un aggiornamento forzato
  #--------------------------------------------------------------------------
  def self.forzato?
    return @forza
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il link del sito per maggiori informazioni
  #--------------------------------------------------------------------------
  def self.url_sito
    return @url_sito
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il nome del file d'immagine da usare come sfondo
  #--------------------------------------------------------------------------
  def self.nomeimmagine
    if @nomeimmagine != nil
      scarica_immagine if @nomeimmagine[0..6]=="http://" #scarica se è un link
      if file_buono?("./Graphics/Pictures/"+File::basename(@nomeimmagine))
        return File::basename(@nomeimmagine)
      else
        return ""
      end
    end
    return Settings::Immagine if Settings::Usa_Immagine == true
    return nil
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il nome del file d'immagine da usare come sfondo
  #--------------------------------------------------------------------------
  def self.link_immagine
    return @nomeimmagine
  end
  
  #--------------------------------------------------------------------------
  # * Scarica l'immagine
  #--------------------------------------------------------------------------
  def self.scarica_immagine
    Net::HTTP.download(@nomeimmagine,"./Graphics/Pictures/")
    loop{break if Net::HTTP.loaded?(File::basename(@nomeimmagine))}
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce l'array con le righe della descrizione
  #--------------------------------------------------------------------------
  def self.descrizione
    return @descrizione
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il nome del file di patch
  #--------------------------------------------------------------------------
  def self.nome_patch
    return File::basename(@url_patch)
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce true se dev'essere aperto il percorso del gioco
  #--------------------------------------------------------------------------
  def self.aprire_cartella?
    return @apertura
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il percorso dove andrà salvato il file d'aggiornamento
  #--------------------------------------------------------------------------
  def self.destinazione_download
    return cartella_utente_win+"/Download/" if File.directory?(cartella_utente_win+"Download")
    return cartella_utente_win+"/" if File.directory?(cartella_utente_win) and versione_windows >= 6
    return "./"
  end
      
  #--------------------------------------------------------------------------
  # * Scarica il file d'aggiornamento
  #--------------------------------------------------------------------------
  def self.scarica_patch
    Net::HTTP.download(@url_patch,destinazione_download)
  end
  
  #-----------------------------------------------------------------------------
  # *Elimina il file temporaneo per aggiornarlo prima di un download.
  # inserire il nome del file.
  #-----------------------------------------------------------------------------
  def self.refresh_file(nomefile)
    path = appdata+"/Microsoft/Windows/Temporary Internet Files/Content.IE5"
    Dir.foreach(path) {|x|                        #per ogni file nel percorso
      next if x == "." or x == ".."               #passa al prossimo se è ind.
      if File.directory?(path+"/"+x)              #se il file è una cartella
        folder = path+"/"+x                       #entra nella cartella
        Dir.foreach(folder) {|y|                  #per ogni file nella cartella
          next if File.directory?(folder+"/"+y)   #passa al prossimo se è una c.
          if no_ext(nomefile) == y[0..no_ext(nomefile).size-1]#se l'inizio del nome corrisp.
            File.delete(folder+"/"+y)             #eliminalo
          end
        }
      end
    }
  end  
  
  #-----------------------------------------------------------------------------
  # * Restituisce il nome del file senza estensione.
  #-----------------------------------------------------------------------------
  def self.no_ext(nomefile)
    nome = nomefile.split(".")
    return nome[0]
  end
  
  # -------------------------------------------------------------------------- 
  # Restituisce il nome utente di Windows
  # --------------------------------------------------------------------------
  def self.cartella_utente_win
    name = " " * 128  
    size = "128"  
    username = "\0" * 256 #userprofile
    Win32API.new('kernel32', 'GetEnvironmentVariable', %w(p p l), 'l').call("userprofile", username, 256)
    username.delete!("\0")
    return username.gsub("\\","/")
  end 
  
  # -------------------------------------------------------------------------- 
  # Restituisce la cartella AppData
  # --------------------------------------------------------------------------
  def self.appdata
    name = " " * 128  
    size = "128"  
    username = "\0" * 256 #appdata
    Win32API.new('kernel32', 'GetEnvironmentVariable', %w(p p l), 'l').call("localappdata", username, 256)
    username.delete!("\0")
    return username.gsub("\\","/")
  end 
  
  # -------------------------------------------------------------------------- 
  # Restituisce la versione di Windows in uso
  # --------------------------------------------------------------------------
  def self.versione_windows
    gvex = Win32API.new( 'kernel32', 'GetVersionEx', ['P'], 'I' )
    s = [20+128, 0, 0, 0, 0, '' ].pack('LLLLLa128')
    gvex.call( s );
    a = s.unpack( 'LLLLLa128' )
    indice = a[1].to_f;dec = a[2].to_f/10
    return indice + dec
  end
  
end #Updater

# ==============================================================================
#  * CLASSE Window_Command *
# Modifica attributi della classe Window_Command
# ==============================================================================
class Window_Command < Window_Selectable
  
  attr_accessor :item_max #abilita l'attributo in scrittura
  
end

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  Aggiungo i metodi alla Scene_Title.
#==============================================================================
class Scene_Title < Scene_Base
  
  #--------------------------------------------------------------------------
  # * Aggiunge funzioni allo start
  #--------------------------------------------------------------------------
  alias start_update start unless $@
  def start
    @agg_disp = Updater.update_avaiable? #@agg_disp è true se c'è un aggiornam.
    start_update
    crea_immagine if @agg_disp and Updater::Settings::Attiva_Popup
    crea_finestra_popup
    @pops = false #gestisce il movimento dell'immagine a intermittenza
    RPG::SE.new(Updater::Settings::Suono_Popup).play if @agg_disp
  end
  
  # -------------------------------------------------------------------------- 
  # * Modifica del metodo d'aggiornamento.
  # --------------------------------------------------------------------------   
  alias update_updater update unless $@
  def update
    testo = Updater::Settings::T_Menu
    if (Input.trigger?(Input::C) and @command_window != nil and
    @command_window.commands[@command_window.index] == testo)
      vai_aggiornamento
    else
      update_updater
      #aggiorna_immagine if Updater::Settings::Attiva_Popup and @agg_disp == true
    end
  end
  
  # -------------------------------------------------------------------------- 
  # * Modifica del metodo d'aggiornamento.
  # --------------------------------------------------------------------------
  def crea_immagine
    @imm_popup = Sprite.new
    @imm_popup.bitmap = Cache.picture(Updater::Settings::Popup_Immagine)
    @imm_popup.x = @command_window.x+@command_window.width+2
    @imm_popup.y = @command_window.y+(24*@command_window.row_max)-(@imm_popup.height/2)
    @imm_popup.z = 99
    @imm_popup.opacity = 0
  end
  
  # -------------------------------------------------------------------------- 
  # * Aggiorna il movimento dell'immagine
  # --------------------------------------------------------------------------
  def aggiorna_immagine
    if @pops == true
      @imm_popup.opacity -= 3
      @pops = false if @imm_popup.opacity < 100
    else
      @imm_popup.opacity += 3
      @pops = true if @imm_popup.opacity > 250
    end
  end
  
  # -------------------------------------------------------------------------- 
  # * modifica del metodo del command_continue
  # --------------------------------------------------------------------------
  alias updata_continue command_continue unless $@
  def command_continue
    if @finestra_popup.visible == true
      chiudi_popup
      return
    end
    if @agg_disp and Updater.forzato?
      errore
      return
    end
    updata_continue
  end
  
  # -------------------------------------------------------------------------- 
  # * Modifica del metodo command_new_game
  # --------------------------------------------------------------------------
  alias updata_newgame command_new_game unless $@
  def command_new_game
    if @finestra_popup.visible == true
      chiudi_popup
      return
    end
    if @agg_disp and Updater.forzato?
      errore
      return
    end
    updata_newgame
  end
  
  # -------------------------------------------------------------------------- 
  # * Crea la grafica della finestra di popup
  # --------------------------------------------------------------------------
  def crea_finestra_popup
    @finestra_popup = F_Popup.new
    @finestra_popup.x = (Graphics.width-@finestra_popup.width)/2
    @finestra_popup.y = (Graphics.height-@finestra_popup.height)/2
    @finestra_popup.visible = false
  end
  
  # -------------------------------------------------------------------------- 
  # * Fa apparire un messaggio d'errore (quando l'aggiornamento è forzato)
  # --------------------------------------------------------------------------
  def errore
    Sound.play_buzzer
    @command_window.active = false if @command_window != nil
    @finestra_popup.visible = true
    Graphics.update
    loop {Input.update; break if Input.trigger?(Input::C)}
    chiudi_popup
  end
  
  # -------------------------------------------------------------------------- 
  # * Chiude il messaggio d'errore
  # --------------------------------------------------------------------------
  def chiudi_popup
    Sound.play_decision
    @command_window.active = true   if @command_window != nil
    @finestra_popup.visible = false
  end
  
  # ============================================================================
  # * Modifica il metodo create_command_window per aggiungere l'opzione
  # di aggiornamento. L'opzione è visibile solo se viene trovato un nuovo 
  # aggiornamento.
  # ============================================================================  
  alias create_command_window_updater create_command_window unless $@
  def create_command_window
    create_command_window_updater
    return unless @agg_disp
    return if @command_window == nil
    @command_window.commands.push(Updater::Settings::T_Menu)
    @command_window.item_max += 1
    @command_window.create_contents
    @command_window.height += 24
    @command_window.y -= 24
    @command_window.refresh
    @leftside = false
    x = @command_window.commands.index(Vocab.continue)
    @command_window.draw_item(x, false) unless @continue_enabled
    if @agg_disp and Updater.forzato?
      @command_window.draw_item(1, false)
      @command_window.draw_item(0, false)
    end
  end
  #--------------------------------------------------------------------------
  # * Va alla schermata di aggiornamento
  #--------------------------------------------------------------------------
  def vai_aggiornamento
    Sound.play_decision
    $scene = Schermata_Aggiornamento.new
  end
  
  # -------------------------------------------------------------------------- 
  # * Modifica del metodo terminate
  # --------------------------------------------------------------------------
  alias updata_terminate terminate unless $@
  def terminate
    @imm_popup.opacity = 0 if @imm_popup != nil
    updata_terminate
    @finestra_popup.dispose
    @imm_popup.dispose if @imm_popup != nil
  end
  
    
end #scene_title

#==============================================================================
# ** Schermata_Aggiornamento
#------------------------------------------------------------------------------
#  La schermata dove verrà scaricato l'aggiornamento del gioco.
#==============================================================================
class Schermata_Aggiornamento < Scene_Base
  
  #--------------------------------------------------------------------------
  # * Inizio
  #--------------------------------------------------------------------------
  def start
    crea_sfondo             #crea e sceglie lo sfondo
    inizializza_variabili   #inizializza le variabili
    crea_finestre           #crea le finestre necessarie
    crea_grafica            #crea gli sprite
  end
  
  #--------------------------------------------------------------------------
  # * Crea lo sfondo della schermata
  #--------------------------------------------------------------------------
  def crea_sfondo
    if Updater.nomeimmagine == nil
      create_menu_background
    else
      @sfondo = Sprite.new
      @sfondo.bitmap = Cache.picture(Updater.nomeimmagine)
      @sfondo.bitmap.blur if Updater::Settings::Sfuoca_Sfondo
      @sfondo.zoom_x = Graphics.width.to_f/@sfondo.width.to_f
      @sfondo.zoom_y = Graphics.height.to_f/@sfondo.height.to_f
    end
  end
  
  #--------------------------------------------------------------------------
  # * Inizializza le variabili necessarie
  #--------------------------------------------------------------------------
  def inizializza_variabili
    @stato = 0                            #stato della schermata
    @larghezza_barra = Graphics.width-32  #larghezza della barra download
    @altezza_barra = 5                    #altezza della barra download
    @percentuale = 0                      #percentuale di completamento
    #valori dello stato:
    #0: Inizio della schermata
    #1: Preparazione al download
    #2: Download in corso
    #3: Download completato
  end
  
  #--------------------------------------------------------------------------
  # * Crea le finestre necessarie
  #--------------------------------------------------------------------------
  def crea_finestre
    crea_finestra_info        #contiene le informazioni sulla versione
    crea_finestra_comandi     #contiene i comandi aggiorna, sito ed esci
    crea_finestra_download    #contiene la percentuale di download
    crea_finestra_descrizione #contiene la descrizione sull'aggiornamento
  end
  
  #--------------------------------------------------------------------------
  # * Crea la finestra delle informazioni
  #--------------------------------------------------------------------------
  def crea_finestra_info
    @finestra_info = Finestra_Updateinfo.new
    @finestra_info.y = 0-@finestra_info.height
    @finestra_info.opacity = Updater::Settings::Opacita
  end
  
  #--------------------------------------------------------------------------
  # * Crea la finestra dei comandi
  #--------------------------------------------------------------------------
  def crea_finestra_comandi
    scarica = Updater::Settings::TM_Sca
    info = Updater::Settings::TM_Inf
    esci = Updater::Settings::TM_Esc
    if Updater.url_sito != nil
      @finestra_comandi = Window_Command.new(Graphics.width,[scarica,info,esci],3,1)
    else
      @finestra_comandi = Window_Command.new(Graphics.width,[scarica,esci],2,1)
    end
    @finestra_comandi.openness = 0
    @finestra_comandi.active = false
    @finestra_comandi.y = @finestra_info.height
    @finestra_comandi.opacity = Updater::Settings::Opacita
  end
  
  #--------------------------------------------------------------------------
  # * Crea la finestra sul download (inizialmente nascosto)
  #--------------------------------------------------------------------------
  def crea_finestra_download
    @finestra_download = Finestra_Updatedownload.new
    @finestra_download.x = 0-@finestra_download.width
    @finestra_download.y = (Graphics.height/2)-@finestra_download.height
    @finestra_download.opacity = 0
    @finestra_download.contents_opacity = 0
  end
  
  #--------------------------------------------------------------------------
  # * Crea la finestra di descrizione (nascosta se non ci sono descrizioni)
  #--------------------------------------------------------------------------
  def crea_finestra_descrizione
    y = @finestra_download.height*2+@finestra_download.y
    @finestra_descrizione = Descrizione_Download.new(y,Updater.descrizione)
    @finestra_descrizione.y = Graphics.height
    @finestra_descrizione.opacity = Updater::Settings::Opacita
  end
  
  #--------------------------------------------------------------------------
  # * Crea la banda nera per sfondo del download
  #--------------------------------------------------------------------------
  def crea_banda
    @barra_nera = Sprite.new
    @barra_nera.bitmap = rett_nero
    @barra_nera.oy = @barra_nera.height/2
    @barra_nera.y = @finestra_download.height+@finestra_download.y
    @barra_nera.zoom_y = 0
    @barra_nera.opacity = 0
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce un bitmap di un rettangolo nero
  #--------------------------------------------------------------------------
  def rett_nero
    nero = Color.new(0,0,0,150)
    immagine = Bitmap.new(Graphics.width,@finestra_download.height*2)
    immagine.fill_rect(0,5,immagine.width,immagine.height-10,nero)
    immagine.blur
    return immagine
  end
  
  #--------------------------------------------------------------------------
  # * Crea le immagini necessarie
  #--------------------------------------------------------------------------
  def crea_grafica
    crea_banda
    crea_barra
  end
  
  #--------------------------------------------------------------------------
  # * Crea la barra di download
  #--------------------------------------------------------------------------
  def crea_barra
    @sfondobarra = Sprite.new
    @barra = Sprite.new
    @sfondobarra.bitmap = colore_sfondobarra
    @barra.zoom_x = 0
    @barra.bitmap = colore_barra
    @sfondobarra.opacity = 0
    @barra.opacity = 0
    @barra.x = Graphics.width
    @barra.y = Graphics.height/2
    @sfondobarra.x = @barra.x
    @sfondobarra.y = @barra.y
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce l'immagine dello sfondo della barra vuota
  #--------------------------------------------------------------------------
  def colore_sfondobarra
    l = @larghezza_barra
    a = @altezza_barra
    colore = Color.new(50,50,50,200)
    colore2 = Color.new(100,100,100,200)
    immagine = Bitmap.new(l,a)
    if Updater::Settings::Aspetto == 2
      immagine.gradient_fill_rect(0,0,l,a,colore,colore2,true)
    else
      immagine.fill_rect(0,0,l,a,colore)
    end
    return immagine
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce l'immagine della barra piena
  #--------------------------------------------------------------------------
  def colore_barra
    l = @larghezza_barra
    a = @altezza_barra
    col = Updater::Settings::Colore
    if Updater::Settings::Aspetto == 0
      colore = Color.new(col[0],col[1],col[2])
    else
      colore1 = Color.new(col[0]*1.5,col[1]*1.5,col[2]*1.5)
      colore2 = Color.new(col[0]*0.5,col[1]*0.5,col[2]*0.5)
    end
    immagine = Bitmap.new(l,a)
    case Updater::Settings::Aspetto
    when 0
      immagine.fill_rect(0,0,l,a,colore)
    when 1
      immagine.gradient_fill_rect(0,0,l,a,colore1,colore2)
    when 2
      immagine.gradient_fill_rect(0,0,l,a,colore1,colore2,true)
    end
    return immagine
  end
  
  #--------------------------------------------------------------------------
  # * Aggiornamento
  #--------------------------------------------------------------------------
  def update
    invio if Input.trigger?(Input::C)
    esci if Input.trigger?(Input::B)
    @finestra_descrizione.su if Input.repeat?(Input::UP)
    @finestra_descrizione.giu if Input.repeat?(Input::DOWN)
    aggiorna_finestre
    aggiorna_movimenti
    aggiorna_stato
  end
  
  #--------------------------------------------------------------------------
  # * Esecuzione del tasto azione
  #--------------------------------------------------------------------------
  def invio
    case @stato
    when 0
      return if @finestra_comandi.active == false
      case @finestra_comandi.index
      when 0
        RPG::SE.new(Updater::Settings::Suono_Iniziato).play
        prepara_download
      when 1
        Sound.play_decision
        if Updater.url_sito == nil
          esegui_uscita
        else
          apri_sito
        end
      when 2
        esegui_uscita
      end
    when 3
      installa_patch
    end
  end
  
  #--------------------------------------------------------------------------
  # * Prepara il download
  #--------------------------------------------------------------------------
  def prepara_download
    @finestra_comandi.active=false
    @stato = 1
  end
  
  #--------------------------------------------------------------------------
  # * Apri il sito all'indirizzo
  #--------------------------------------------------------------------------
  def apri_sito
    Thread.new{system("explorer "+Updater.url_sito)}
  end
  
  #--------------------------------------------------------------------------
  # * Esecuzione di uscita
  #--------------------------------------------------------------------------
  def esci
    if @stato == 0 and @finestra_comandi.active == true
      Sound.play_cancel
      esegui_uscita
    end
  end
      
  #--------------------------------------------------------------------------
  # * Aggiornamento delle finestre
  #--------------------------------------------------------------------------
  def aggiorna_finestre
    @finestra_comandi.update
    if @stato == 2
      @percentuale = Net::HTTP.progress(Updater.nome_patch) rescue return
      #a volte la chiamata a progress faceva crashare il gioco
      @finestra_download.setta(@percentuale)
    end
    
  end
  
  #--------------------------------------------------------------------------
  # * Aggiornamento dei movimenti di immagini e finestre
  #--------------------------------------------------------------------------
  def aggiorna_movimenti
    case @stato
    when 0
      distanza = @finestra_info.y
      @finestra_info.y -= distanza/2
      meta = @finestra_download.height*2+@finestra_download.y
      distanza = @finestra_descrizione.y-meta
      @finestra_descrizione.y-=distanza/2
      @finestra_comandi.openness += 48
    when 1
      @barra_nera.opacity +=25
      @barra_nera.zoom_y += 0.05 if @barra_nera.zoom_y < 1.0
      distanza = 0-@finestra_download.x
      @finestra_download.x += distanza/2
      @finestra_download.contents_opacity += 25
      distanza = @barra.x-16
      @barra.x -= distanza/2
      @sfondobarra.x = @barra.x
      @sfondobarra.opacity += 25
      @finestra_comandi.openness -=48
      @finestra_descrizione.openness -=48
    when 2,3
      aggiorna_barra
    end
  end
  
  #--------------------------------------------------------------------------
  # * Muove la barra rispetto alla percentuale completata
  #--------------------------------------------------------------------------
  def aggiorna_barra(completo = false)
    completo ? v=2.0 : v = 3.0
    ampiezza = @percentuale.to_f / 100
    distanza = ampiezza - @barra.zoom_x
    @barra.zoom_x += distanza/v
  end
  
  #--------------------------------------------------------------------------
  # * Cambia lo stato
  #--------------------------------------------------------------------------
  def aggiorna_stato
    case @stato
    when 0
      @finestra_comandi.active = true if @finestra_comandi.openness == 255
    when 1
      inizia_download if @sfondobarra.opacity == 255 and @barra_nera.zoom_y >=1.0
    when 2
      download_completato if Net::HTTP.loaded?(Updater.nome_patch)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Inizia lo scaricamento della patch
  #--------------------------------------------------------------------------
  def inizia_download
    Updater.scarica_patch
    @barra.opacity = 255
    @stato = 2
    for i in 0..10
    end
  end
  
  #--------------------------------------------------------------------------
  # * Esecuzione del download completato
  #--------------------------------------------------------------------------
  def download_completato
    RPG::SE.new(Updater::Settings::Suono_Completato).play
    @stato = 3
    aggiorna_finestra_info
  end
  
  #--------------------------------------------------------------------------
  # * Aggiorna la finestra
  #--------------------------------------------------------------------------
  def aggiorna_finestra_info
    @finestra_info.completa
    @finestra_download.setta(101)
    @percentuale = 100
    aggiorna_barra(true)
  end
  
  #--------------------------------------------------------------------------
  # * Processo di terminazione
  #--------------------------------------------------------------------------
  def terminate
    elimina_finestre
    elimina_immagini
  end
  
  #--------------------------------------------------------------------------
  # * Elimina le finestre
  #--------------------------------------------------------------------------
  def elimina_finestre
    @finestra_comandi.dispose
    @finestra_info.dispose
    @finestra_download.dispose
    @finestra_descrizione.dispose
  end
  
  #--------------------------------------------------------------------------
  # * Elimina le immagini
  #--------------------------------------------------------------------------
  def elimina_immagini
    if Updater.nomeimmagine == nil
      dispose_menu_background
    else
      @sfondo.bitmap.dispose
      @sfondo.dispose
    end
    @barra.bitmap.dispose
    @barra.dispose
    @sfondobarra.bitmap.dispose
    @sfondobarra.dispose
    @barra_nera.bitmap.dispose
    @barra_nera.dispose
  end
  
  #--------------------------------------------------------------------------
  # * Esecuzione dell'apertura della patch
  #--------------------------------------------------------------------------
  def installa_patch
    RPG::BGM.fade(800)
    RPG::BGS.fade(800)
    RPG::ME.fade(800)
    $scene = nil
    if Updater.aprire_cartella?
      percorso = Updater.converti_UNC(File::expand_path("./"))
      codice = "explorer "+percorso
      Thread.new{system(codice)}
    end
    codice = "explorer "+Updater.converti_UNC(Updater.destinazione_download+Updater.nome_patch)
    Thread.new{system(codice)}
  end
  
  #--------------------------------------------------------------------------
  # * Esce dalla schermata di download
  #--------------------------------------------------------------------------
  def esegui_uscita
    $scene = Scene_Title.new
  end
  
end #schermata_download

#==============================================================================
# ** Finestra_Updateinfo
#------------------------------------------------------------------------------
#  Questa classe si occupa delle informazioni sull'aggiornamento.
#==============================================================================
class Finestra_Updateinfo < Window_Base
  def initialize
    super(0,0,Graphics.width,(WLH*2)+32)
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Rinfresca
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    testo = sprintf(Updater::Settings::T_Aggu,Updater.versione_disponibile)
    self.contents.draw_text(4,0,self.width-32,WLH,testo)
    testo = sprintf(Updater::Settings::T_Aggd,Updater.versione_attuale)
    self.contents.draw_text(4,WLH,self.width-32,WLH,testo)
  end
  
  #--------------------------------------------------------------------------
  # * Cambia lo stato in download completato
  #--------------------------------------------------------------------------
  def completa
    self.contents.clear
    testo = sprintf(Updater::Settings::T_Agg3,Updater.converti_UNC(Updater.destinazione_download+Updater.nome_patch))
    self.contents.draw_text(4,0,self.width-32,WLH,testo)
    testo = sprintf(Updater::Settings::T_Agg4)
    self.contents.draw_text(4,WLH,self.width-32,WLH,testo)
  end
end #finestra_updateinfo

#==============================================================================
# ** Finestra_Updatedownload
#------------------------------------------------------------------------------
#  Questa classe mostra la percentuale di download in corso
#==============================================================================
class Finestra_Updatedownload < Window_Base
  #--------------------------------------------------------------------------
  # * Inizializzazione
  #--------------------------------------------------------------------------
  def initialize
    super(0,0,Graphics.width,WLH+32)
    @percentuale = 0
    @totale = 0
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Riceve come parametro la nuova percentuale
  #--------------------------------------------------------------------------
  def setta(perc)
    @percentuale = perc
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Rinfresca la finestra
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    if Net::HTTP.size(Updater.nome_patch) != nil
      @totale = Net::HTTP.size(Updater.nome_patch)
    end
    if @percentuale <= 100
      testo = sprintf(Updater::Settings::T_DinC,@percentuale)
    else # se è superiore a 100 mostra download completato
      testo = Updater::Settings::T_Comp
    end
    testo+=sprintf(" (%.2fkB)",@totale.to_f/1000.0)
    self.contents.draw_text(4,0,self.width-32,WLH,testo)
  end
end #finestra_updatedownload

#==============================================================================
# ** F_Popup
#------------------------------------------------------------------------------
#  Questa finestra compare nel titolo
#==============================================================================
class F_Popup < Window_Base
  #--------------------------------------------------------------------------
  # * Normale inizializzazione
  #--------------------------------------------------------------------------
  def initialize
    super(0,0,350,WLH+32)
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Rinfresca la finestra
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.draw_text(4,0,self.width-32,WLH,Updater::Settings::T_Popp)
  end
end #f_popup

#==============================================================================
# ** Descrizione_Download
#------------------------------------------------------------------------------
#  Questa finestra compare in basso allo schermo se ci sono descrizioni
#==============================================================================
class Descrizione_Download < Window_Base
  def initialize(posizioney,array_testo)
    super(0,posizioney,Graphics.width,Graphics.height-posizioney)
    @max_righe = calcola_righe
    @testo = array_testo
    @testo.size > 0 ? self.visible = true : self.visible = false
    @index = 0
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Restituisce il numero di righe che può visualizzare
  #--------------------------------------------------------------------------
  def calcola_righe
    return (self.height-32)/WLH
  end
  
  #--------------------------------------------------------------------------
  # * Rinfresca la finestra
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    return if @testo.size == 0
    for i in 0..@testo.size-1
      text = @testo[i].gsub("[b]","●")
      self.contents.draw_text(4,WLH*(i+@index),self.width-32,WLH,text)
    end
    disegna_barra if @testo.size > @max_righe
  end
  
  #--------------------------------------------------------------------------
  # * Muove le scritte sopra
  #--------------------------------------------------------------------------
  def giu
    return if @index <= @max_righe-@testo.size or self.openness < 255
    Sound.play_cursor
    @index -=1
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Muove le scritte in basso
  #--------------------------------------------------------------------------
  def su
    return if @index >= 0 or self.openness < 255
    Sound.play_cursor
    @index +=1
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Disegna la barra di scorrimento, nel caso ci siano più righe
  #--------------------------------------------------------------------------
  def disegna_barra
    larg_barra = 10
    x=self.width-32-larg_barra
    altbar = self.height-32
    self.contents.fill_rect(x,0,larg_barra,altbar,gauge_back_color)
    altezza = altbar/(@testo.size-(@max_righe-1))
    y=@index*((altbar-altezza)/(@testo.size-@max_righe))*-1
    self.contents.fill_rect(x,y,larg_barra,altezza,normal_color)
  end
end #finestra_descrizione

 

 

Bugs e Conflitti Noti[/b]

Nessun bug rilevato, ho prestato massima attenzione alla compatibilità con gli script e si adatta automaticamente ad ogni risoluzione (nel caso l'aveste cambiata)

Se trovate qualche bug, conflitto o imprecisione, fatemelo sapere e provvederò a tagliarvi la gol... ehm, a risolvere il problema :ph34r:

Altri Dettagli

Screenshot:

 

 

http://img145.imageshack.us/img145/5000/titlescreen.png

http://img217.imageshack.us/img217/4510/downloadscreen.png

 

 

 

Edited March 16, 2013 by Holy87
Aggiornamento 2.2

[Gianmark]

Accidenti, geniale, lo userò senz'altro.

Ma se si usa un menù custom programmato ad eventi..? :/

[Holy87]

Accidenti, geniale, lo userò senz'altro.

Ma se si usa un menù custom programmato ad eventi..? :/

Beh non è difficile cambiare l'interfaccia tramite script e metterci qualche immagine al posto delle finestre, sarebbe troppo elaboriosa invece un menu ad eventi...

[Gianmark]

Se rinunciassi al pop-up non basterebbe un call script allo script che gestisce l'aggiornamento (modificandolo un pò, immagino ovviamente)? Edited September 6, 2011 by Gianmark

[Holy87]

Se rinunciassi al pop-up non basterebbe un call script allo script che gestisce l'aggiornamento (modificandolo un pò, immagino ovviamente)

$scene = Scene_Updater.new

Poi però devi modificare la "def turn_to_title" che invece di riportarti a Scene_Title ti riporta a Scene_Map.

 

Per controllare l'aggiornamento, devi mettere in un call script con

UPDATER.check_update

mentre se vuoi una condizione nel caso abbia trovato o no un aggiornamento, nel fork come condizione scegli script, e inserisci

$update_avaiable

Edited September 6, 2011 by Holy87

[Guardian of Irael]

Ottimo lavoro Holy e soprattutto bel topic e buona descrizione, pure il link di prova :3

Anche lo script vedo molto curato con barre caricamento avvisi, processi automatici... :D

Magari un po' laborioso per i meno esperti, ma... pioggia di rens :rovatfl: XD

^ ^

[Holy87]

Ottimo lavoro Holy e soprattutto bel topic e buona descrizione, pure il link di prova :3

Anche lo script vedo molto curato con barre caricamento avvisi, processi automatici... :D

Magari un po' laborioso per i meno esperti, ma... pioggia di rens :rovatfl: XD

^ ^

Grazie dei complimenti :D

 

Tutto quello che deve fare chi uppa i giochi è creare una patch e metterla online, il resto dei settaggi si limita a indicare il link per il download. È ovvio che comunque sia un procedimento laborioso, ma daltronde non è uno script convenzionale, c'è bisogno di molta attenzione e precisione ma, il risultato c'è.

E comunque, ho cercato come mio solito di mettere più commenti possibili nello script (marea di commenti), in modo da rendere più facile la lettura di qualcuno che voglia personalizzarlo, o semplicemente di prendere qualche parte di codice utile nel suo progetto, evitando di imprecare e bestemmiare cercando di trovare le chiamate di sistema e tutte le funzioni del ruby nascoste come ho fatto io.

[Narutofan95]

Fantastico! *-*

Io avevo pensato a sviluppare un programma esterno da avviare al posto di avviare il gioco (per chiedere prima gli aggiornamenti, e poi avviarlo da sé) ma questo è seriamente imbattibile!

[Holy87]

Fantastico! *-*

Io avevo pensato a sviluppare un programma esterno da avviare al posto di avviare il gioco (per chiedere prima gli aggiornamenti, e poi avviarlo da sé) ma questo è seriamente imbattibile!

Avevo pensato anche io a questa soluzione, ma effettivamente il metodo in-game è molto più facile da vedere. D'altronde programmare in Ruby è più facile che in C o C++, risparmia un sacco di tempo :rovatfl:

[Gianmark]

Grazie mille, Holy. Domani mattina proverò a implementarlo E' davvero un bel lavoro, visto che non lo avevo già fatto, mi complimento

[Melosx]

Raga ma gliela fate la targhetta Miglior Scripter del Secolo??? E' una genialata

Mi chiedevo...

Se, ad esempio, la versione è la 1.3 e creo una patch con versione 1.3.1 o 1.3a l'updater le riconosce come nuove versioni o devo perforza mettere 1.4??

[Holy87]

Raga ma gliela fate la targhetta Miglior Scripter del Secolo??? E' una genialata

Mi chiedevo...

Se, ad esempio, la versione è la 1.3 e creo una patch con versione 1.3.1 o 1.3a l'updater le riconosce come nuove versioni o devo perforza mettere 1.4??

Addirittura una targhetta? XD

Non voglio complimenti o targhette, voglio denaro! >:-)

Comunque, il problema è che Ruby non gestisce nativamente numeri con più virgole, avrei dovuto creare una nuova classe per gestire questo nuovo tipo di dati, e mi sembrava eccessivo. Comunque, puoi anche fare in modo di rilasciare versioni 1.05, 1.12 ad esempio, tenendo la cifra meno significativa come bugfix, la cifra decimale più significativa come minor release, e quella intera come major release. Esempio: aggiornare il gioco dalla versione 1.1 alla 1.11.

[Gianmark]

Holy, eventualmente questo script potrebbe essere utilizzato per distribuire DLC (gratuitamente, si intende o,o)?

[Holy87]

Holy, eventualmente questo script potrebbe essere utilizzato per distribuire DLC (gratuitamente, si intende o,o)?

Certamente, se lo metti come aggiornamento. Ricordati però che ogni patch deve contenere necessariamente anche tutte le patch precedenti, perchè nel caso dalla 1.0 non aggiorno la 1.1 e vado direttamente alla 1.2, la 1.2 deve contenere anche gli aggiornamenti della patch 1.1, altrimenti potrebbero essere generati dei conflitti.

[Gianmark]

Sì, lo avevo capito :sìsì:

[Holy87]

Novità! Ho aggiunto una documentazione dettagliata sullo script: come funziona e come si usa al meglio. Se qualcuno ha dei dubbi, può scaricarla da questo link.

 

Inoltre, ecco la mia roadmap per lo script, con tutte le implementazioni:

0.9:Versione iniziale->1.0: sistemazione, pulizia del codice e bugfix per migliore stabilità ->1.1: il numero di versione è memorizzato su un log nel gioco, non nello script->...

 

Nelle versioni successive, le idee che cercherò di implementare sono:

-introdurre aggiornamenti obbligatori (se c'è un aggiornamento obbligatorio, il giocatore non può continuare a giocare se non aggiorna)

-Funzione ERASE: Far si che il gioco si autodistrugga con un comando da remoto!

-Non solo download, ma anche installazione automatica in-game degli aggiornamenti.

[Melosx]

Holy stavo pensando... L'updater al posto di cercare l'ultima disponibile dovrebbe cercare le patch in serie...

Mi spiego se ho le patch 1.1 e 1.2 non dovrebbe scaricare subito la 1.2 ma prima la1.1 e dopo la 1.2... Ciò renderebbe le patch più leggere(specialmente se l'ultima contiene 20 patch di roba ci voglion secoli per scaricarla) ed evita conflitti/errori qualora si dimentica di agiungere file della precedente versione...

Un sistema cosi viene usato in Neverwinter Nights 2...

[Holy87]

Holy stavo pensando... L'updater al posto di cercare l'ultima disponibile dovrebbe cercare le patch in serie...

Mi spiego se ho le patch 1.1 e 1.2 non dovrebbe scaricare subito la 1.2 ma prima la1.1 e dopo la 1.2... Ciò renderebbe le patch più leggere(specialmente se l'ultima contiene 20 patch di roba ci voglion secoli per scaricarla) ed evita conflitti/errori qualora si dimentica di agiungere file della precedente versione...

Un sistema cosi viene usato in Neverwinter Nights 2...

Si ci ho pensato anche io, ma pensa tu che non aggiorni da tanto, ti restano 3-4 patch e che fai? Apri il gioco, scarichi e installi per 4 volte? Il giocatore si rompe, vuole solo giocare. E comunque, puoi benissimo farlo lo stesso con lo script: ad esempio che la posizione del file info cambia continuamente. Mi spiego: fino alla versione 1.5, il link della patch è www.sito.it/info1.txt, dall'aggiornamento della versione 1.5, il prossimo link per l'info è www.sito.it/info2.txt. In questo modo, solo se ha scaricato l'aggiornamento 1.5 potrà scaricare i prossimi aggiornamenti.

Si potrebbe fare una via di mezzo: quando la patch raggiunge dimensioni di 5-7Mb, è arrivato il momento di cambiare link.

[Melosx]

Per il fatto "...Il giocatore si rompe..." hai ragione... Ricordo le ore passate ad aggiornare Neverwinter 2 con patch di 100 e passa mega... La soluzione da te esposta può andare...

[Holy87]

Aggiornamento: Nuova versione 1.0. Release finalmente stabile, corretti vari bug, alleggerito e sistemato il codice. >Download

 

Questa versione l'avevo pronta da diverse settimane, ma mi dimenticavo di postarla

Buon making a tutti!

[Melosx]

bene la nuova versione... Qualche link per testarla noi poveri mortali??

[Holy87]

bene la nuova versione... Qualche link per testarla noi poveri mortali??

Il link è sempre lo stesso. Visibilmente non cambia niente, i miglioramenti sono sotto il cofano.

[Armored]

Questo script è F-A-V-O-L-O-S-O.

Però.... C'è un paio di cose.

 

Nello script, c'è scritto che bisogna saper fare delle patch.

Posso chiederti come è possibile farne?

Voglio dire, una mezza idea ce l'ho, ma come intendo io significherebbe ogni volta scaricare tutto il gioco. Si, ossia mettere Graphic, Data e Audio così rozzamente. Non credo sia questo il sistema, dato che le patch del tuo progetto sono relativamente leggere...

Ho cercato sia sul forum che su google, con scarsi risultati...

Quindi, non è che puoi illuminarmi su questo? (Anche per chi, come me, non ha ben afferrato)...

 

Detto questo, ho paura che, in futuro, avrò bisogno di una modifica per lo script, se sei disponibile :( (Dato che io non riesco a capirci n'emerita mazza... Ma se non vuoi/puoi fa niente, eh D: )

[Holy87]

Questo script è F-A-V-O-L-O-S-O.

Però.... C'è un paio di cose.

 

Nello script, c'è scritto che bisogna saper fare delle patch.

Posso chiederti come è possibile farne?

Voglio dire, una mezza idea ce l'ho, ma come intendo io significherebbe ogni volta scaricare tutto il gioco. Si, ossia mettere Graphic, Data e Audio così rozzamente. Non credo sia questo il sistema, dato che le patch del tuo progetto sono relativamente leggere...

Ho cercato sia sul forum che su google, con scarsi risultati...

Quindi, non è che puoi illuminarmi su questo? (Anche per chi, come me, non ha ben afferrato)...

 

Detto questo, ho paura che, in futuro, avrò bisogno di una modifica per lo script, se sei disponibile :( (Dato che io non riesco a capirci n'emerita mazza... Ma se non vuoi/puoi fa niente, eh D: )

Potrei essere disponibile a qualche modifica dello script, certo :)

Per creare le patch, devi tenere conto di cosa modifichi nel gioco. Esempio: modifichi uno script? Includi nella patch il file Scripts.rvdata. Modifichi un evento sulla mappa? Inserisci nella patch quella mappa.

In sostanza, la patch deve contenere SOLO i file interessati dalle modifiche che hai fatto.

[Ichika Strize]

Ed un'altra domandina: la patch che tipo di file deve essere (esempio idiota: Blocco Note, questo è un esempio, anche se non ci centra niente XD)?? ^^" scusa la mia infinita ignoranza Edited December 11, 2011 by Ichika Strize