3
6
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
DescrizioneScarica 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.
AutoreHoly87
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.
Se non intendete usare un popup, impostate "ACTIVATE_POPUP" su false
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.
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.htmCon 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.
- [i] 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.
[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:
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:
Spoiler
$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 [email protected]
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 <= @[email protected] 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_descrizioneBugs 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:
Screenshot:
Spoiler
Modificato da Holy87, 16 March 2013 - 23:42 PM.
Aggiornamento 2.2
