SHARE
TWEET

H87UniversalModule

Holy87 Jul 15th, 2013 (edited) 787 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. $imported = {} if $imported == nil
  2. $imported["H87_UniversalModule"] = 1.6
  3. %Q{
  4.  ==============================================================================
  5.   ■ Utility universali di Holy87
  6.       versione 1.6.2
  7.       Difficoltà utente: ★★★
  8.       Licenza: CC. Chiunque può scaricare, modificare, distribuire e utilizzare
  9.       lo script nei propri progetti, sia amatoriali che commerciali. Vietata
  10.       l'attribuzione impropria.
  11.  
  12.  ■ Questo modulo serve a espandere a nuovi livelli i vostri script e permetter-
  13.    vi di creare feature nel vostro gioco prima impensabili, nel modo più
  14.    semplice e immediato possibile. Cosa è possibile fare?
  15.    ● Salvare delle variabili indipendenti dal salvataggio
  16.    ● Ottenere informazioni dal sistema, quali la risoluzione dello schermo,
  17.      la lingua del sistema, la versione di Windows, il nome utente, il
  18.      percorso della cartella documenti ecc...
  19.    ● Scaricare un file e/o ottenere risposta da un web server, anche in modo
  20.      asincrono e nel modo più facile possibile
  21.    ● Ottenere informazioni sulla versione del gioco o impostarla
  22.    ● Codificare/decodificare una stringa in rot13 o Base64
  23.    ● Altro ancora!
  24. ==============================================================================
  25.  ■ Compatibilità
  26.    DataManager -> alias load_normal_database, load_battle_test_database
  27.    Scene_Base  -> alias update
  28.    Window_Base -> alias update
  29. ==============================================================================
  30.  ■ Installazione
  31.    Installare questo script sotto Materials e prima del Main. Metterlo sopra a
  32.    tutti gli altri script che fanno uso di questo modulo.
  33. ==============================================================================
  34.  ■ Istruzioni
  35.    Usare da script o da chiama evento le seguenti chiamate: quando vedi delle
  36.    parentesi quadre [] a dei valori significa che è facoltativo.
  37.  
  38.  ▼ Valori universali di gioco
  39.    L'oggetto $game_settings è una classe universale che salva e conserva un
  40.     valore indipendentemente dal salvataggio. Può essere usato per memorizzare
  41.     impostazioni nella schermata del titolo, sbloccare gli extra o gestire gli
  42.     obiettivi, o qualsiasi cosa ti venga in mente.
  43.  
  44.     ● $game_settings[quellochevuoi] = ilvalorechevuoi
  45.       memorizza il valore che vuoi, e viene automaticamente salvato nel file
  46.       game_settings.rvdata, che si trova nella cartella del gioco. Il valore
  47.       viene salvato anche se la partita non è stata salvata.
  48.  
  49.     ● $game_settings[quellochevuoi]
  50.       restituisce il valore di quellochevuoi.
  51.      
  52.     ● Puoi impostare la versione del gioco creando un file nel progetto con il
  53.       nome "version.ini", e all'interno scriverci la versione come 1.0.2.5
  54.      Puoi richiamare la versione dal gioco da $game_system.game_version
  55.      Es. versione = $game_system.game_version
  56.      print versione.major => 1
  57.      print versione.minor => 0
  58.      print versione.build => 2
  59.      print versione.revision => 5
  60.      print versione => 1.0.2.5
  61.      print versione > "1.0.1.7" => false
  62.  
  63.  ▼ Chiamate di sistema
  64.  
  65.    ● Win.version:
  66.      restituisce un decimale con il numero di versione di Windows in uso.
  67.        5.0 -> Windows 2000
  68.        5.1 -> Windows Xp
  69.        5.2 -> Windows Xp (64 bit)
  70.        6.0 -> Windows Vista
  71.        6.1 -> Windows 7
  72.        6.2 -> Windows 8
  73.        6.3 -> Windows 8.1
  74.        10.0-> Windows 10
  75.  
  76.    ● Win.username
  77.      Restituisce una stringa con nome utente di Windows attualmente in uso
  78.  
  79.    ● Win.homepath
  80.      Restituisce il percorso utente del computer. Esempio:
  81.      C:/Users/nomeutente/                      in Windows Vista, 7 e 8
  82.      C:/Documents and Settings/nomeutente      in Windows 2000 e Xp
  83.  
  84.    ● Win.getFolderPath([simbolo])
  85.      Restituisce il percorso di una cartella definita dal simbolo:
  86.        :docs -> cartella documenti dell'utente
  87.         :imgs -> cartella immagini dell'utente
  88.        :dskt -> destkop dell'utente
  89.         :musc -> cartella musica dell'utente
  90.        :vdeo -> cartella video dell'utente
  91.         :prog -> cartella dei programmi installati (C:\Programmi (x86))
  92.         * se non è definito un simbolo, viene preso :docs
  93.  
  94.     ● Win.shutdown[(mode)]
  95.       Spegne il computer, a seconda di mode (se si omette è 0):
  96.         0: spegnimento normale
  97.         1: riavvio
  98.         2: ibernazione
  99.  
  100.     ● Win.open(filepath)
  101.       Apre una cartella o un file sul PC. Specificare il percorso in filepath
  102.       Esempi:
  103.         Win.open(C:/Windows/system32/calc.exe) avvierà la calcolatrice
  104.         Win.open(Win.homepath+"/Desktop") aprirà la cartella del desktop
  105.  
  106.     ● Win.temp_flush(nomefile)
  107.       elimina il file dai file temporanei di internet. Utilizzarlo prima di un
  108.       download di un file che viene aggiornato molto spesso.
  109.  
  110.     ● Win.datenow[(partition)]
  111.       Restituisce la data attuale in stringa in formato "gg/mm/aaaa". Se
  112.       viene inserito partition come valore:
  113.       0: restituisce il numero del giorno in intero
  114.       1: restituisce il numero del mese attuale in intero
  115.       2: restituisce il numero dell'anno attuale in intero
  116.  
  117.    ● Win.timenow[(partition)]
  118.      Restituisce l'ora attuale in formato "hh:mm" (h 0~24)
  119.       partition: 0 -> restituisce le ore in intero
  120.       partition: 1 -> restituisce il minuto attuale 0~59
  121.       partition: 2 -> restituisce i secondi 0~59
  122.      
  123.     ● Win.language
  124.       Restituisce un codice con la lingua del sistema in uso. Per l'elenco delle
  125.      lingue con i rispettivi codici vedere questo link:
  126.      http://support.microsoft.com/kb/193080
  127.  
  128.    ● Win.screen_resolution
  129.      restituisce un array di due interi contenenti la risoluzione in lunghezza
  130.      e altezza dello schermo (es. [1024,730]). Ricordati che non restituisce
  131.      la risoluzione completa, ma solo la parte di schermo utilizzabile (cioè
  132.      quella non nascosta dalla barra delle applicazioni)
  133.  
  134.    ● Screen.resize(lunghezza, larghezza)
  135.      ridimensiona la finestra di gioco. Ricordati che questa funzione non
  136.      aumenta la risoluzione del gioco, ma stretcha limmagine.
  137.      
  138.  ▼ Nuove funzioni per le stringhe
  139.  
  140.    ● println
  141.      come print, solo che dopo va direttamente a capo
  142.    
  143.    ● String.random([n_caratteri])
  144.      Restituisce una stringa casuale di n_caratteri. Se n_caratteri non è
  145.      definito, la stringa sarà di 4.
  146.      Esempi:
  147.      print String.random     #=> ajpf
  148.      print String.random(7)  #=> opetnpg
  149.      
  150.    ● crypt_rot13
  151.      Cripta una stringa in rot13 in modo da essere illeggibile (sposta ogni
  152.      carattere di 13 posti nell'alfabeto). Richiamare il metodo alla stringa
  153.       crittografata per farla tornare normale. Esempi:
  154.       print "Casa".crypt_rot13    #=> "Pnfn"
  155.       print "Pnfn".crypt_rot13    #=> "Casa"
  156.      
  157.     ● Base64.encode(stringa) e Base64.decode(stringa)
  158.       Restituisce una stringa in Base64 per l'interscambio di dati web
  159.      Per ulteriori informazioni: http://it.wikipedia.org/wiki/Base64
  160.  
  161.  ▼ Internet e HTTP
  162.  
  163.    ----------------------------------------------------------------------------
  164.    * Metodi semplificati per operazioni asincrone
  165.    ----------------------------------------------------------------------------
  166.    I metodi semplificati permettono una facile gestione dei download e delle
  167.    risposte su internet in modo da usare meno codice possibile ed essere più
  168.    efficienti. Questi metodi possono essere usati solo in una Scene, Window o
  169.    nelle classi dove viene incluso il modulo Async_Downloads.
  170.    
  171.    ● download_async(url, metodo[, priorità, cartella])
  172.      Avvia il download di un file da url. Lancia automaticamente il metodo
  173.      nome_metodo quando il download è completato
  174.      (il nome del metodo dev'essere passato come simbolo)
  175.       Esempi:
  176.       download_async("www.miosito.com/immagine.jpg", method(:carica_immagine))
  177.       (bisogna anche definire il metodo carica_immagine)
  178.       Il download del file è molto lento per non alterare la fluidità del gioco.
  179.       Se vuoi velocizzare il download, metti true nel campo priorità.
  180.      
  181.     ● get_response_async(url, metodo, priorità)
  182.       Avvia la ricezione della risposta dall'indirizzo dell'url, ed avvia il
  183.       metodo definito da method_name nonappena la risposta è stata ricevuta.
  184.       A differenza del precedente, il metodo da richiamare deve avere un
  185.       parametro in ingresso, che è la stringa della risposta.
  186.      
  187.     ● abort_download(nomefile)
  188.       Annulla il download di nomefile.
  189.      
  190.     ● download_status(filename)
  191.       Restituisce un numero intero da 0 a 100 rappresentante lo stato di download.
  192.      
  193.     ----------------------------------------------------------------------------
  194.     * Metodi più complessi per la gestione completa dei download
  195.     ----------------------------------------------------------------------------
  196.     Questi metodi possono essere usati ovunque e permettono una gestione più
  197.     complessa e funzionale dei download. Possono anche essere usati affiancati
  198.     ai metodi più semplici.
  199.    
  200.     ● await_response(url)
  201.       Avvia la ricezione della risposta e restituisce direttamente la stringa
  202.       senza attesa. Può bloccare l'esecuzione del gioco per qualche secondo,
  203.      perciò meglio metterlo durante caricamenti o cambi di schermata.
  204.      Esempio:
  205.      print await_response(www.miosito.com)
  206.      Una cosa del genere stamperà tutto il codice HTML della pagina.
  207.  
  208.    ● HTTP.domain
  209.      restituisce il dominio principale del tuo server (configura in basso).
  210.      usalo nelle locazioni internet in modo da cambiare velocemente dominio
  211.    
  212.    ● HTTP.download(percorsofile[,destinazione[,bassa priorità]])
  213.      Scarica il file dal percorso. Se il percorso di destinazione è omesso,
  214.      verrà scaricato nella cartella del gioco (cioè "./") Esempio:
  215.      HTTP.download("http://www.miosito.it/immagine.png","./Graphics/Pictures")
  216.        scaricherà immagine.png nella cartella Graphics/Pictures del gioco.
  217.      HTTP.download("http://www.miosito.it/immagine.png")
  218.        scaricherà immagine.png nella cartella del gioco.
  219.      HTTP.download(HTTP.domain+"/immagine.png", Win.getFolderPath(:dskt))
  220.        scaricherà immagine.png da http://www.miosito.it sul desktop.
  221.      Imposta true in bassa priorità per velocizzare il gioco durante il download
  222.      (il download sarà più lento)
  223.      
  224.    ● HTTP.get_server_response(url, response_name)
  225.      Ottiene la risposta o legge il contenuto di un indirizzo web e lo memorizza
  226.      nel proprio contenitore. url è l'indirizzo, mentre response_name è un
  227.       identificatore per ritrovarlo.
  228.      
  229.     ● HTTP.await_response(url)
  230.       come await_response senza HTTP
  231.      
  232.     ● HTTP.response(response_name)
  233.       Restituisce il testo letto da get_server_response. Usalo dopo aver
  234.       prima controllato che il download sia stato effettuato
  235.  
  236.     ● HTTP.downloaded?(nomefile)
  237.       Restituisce true se il file che si sta scaricando è stato scaricato
  238.       completamente. Restituisce false se non è stato neanche iniziato o se è
  239.       ancora in corso. Al posto di nomefile si può mettere il nome della risposta
  240.       per controllare se è stata ricevuta quando si usa get_server_response e
  241.       prima di utilizzare HTTP.response.
  242.      
  243.     ● HTTP.progress(nomefile)
  244.       Restituisce la percentuale di scaricamento del file in un float compreso
  245.       tra 0.0 e 100.0. Restituisce 0 se il download non è cominciato.
  246.  
  247.     ● HTTP.filesize(nomefile)
  248.       restituisce la grandezza del file in bit: dividi per 8 per ottenere i byte.
  249.  
  250.     ● HTTP.sizeloaded(nomefile)
  251.       restituisce il numero di bit scaricati del file: dividi per 8 per ottenere
  252.       i byte.
  253.  
  254.     ● HTTP.time_passed(nomefile)
  255.       restituisce il tempo in secondi del tempo che ha richiesto il download.
  256.       Restituisce 0 se il download non è completato o non esiste.
  257.  
  258.     ● HTTP.downloads
  259.       restituisce un hash contenente l'elenco dei download
  260.  
  261.    ● HTTP.completed
  262.      restituisce il numero dei download completati
  263.      
  264.    ● HTTP.get_file_size(url)
  265.      restituisce la grandezza del file senza scaricarlo
  266.  
  267.    ● HTTP.file_good?(nomefile)
  268.      controlla se il file è stato scaricato correttamente
  269.  
  270.    ● Browser.open(url)
  271.      apre il browser ad un sito scelto. Ricordati che se l'url è troppo grande,
  272.       potrebbe non avviare il sito. In questo caso ti consiglio di usare tinyurl
  273.       o goo.gl per rimpicciolire il link.
  274. }
  275.  
  276. #==============================================================================
  277. module H87_ModConfig
  278.   HTTPDOMAIN = "http://holyres.altervista.org/demoscript"#"http://miosito.com/"
  279.   SETTINGNAME = "game_settings.rvdata2"
  280.   VERSIONFILE = "version.ini"
  281. end
  282. #==============================================================================
  283. # ** Win
  284. #------------------------------------------------------------------------------
  285. #  Questo modulo gestisce le chiamate di sistema e recupera informazioni sul
  286. #  computer
  287. #==============================================================================
  288. module Win
  289.   #-----------------------------------------------------------------------------
  290.   # *Nome Utente Windows
  291.   # Restituisce il nome utente di Windows
  292.   #-----------------------------------------------------------------------------
  293.   def self.username
  294.     name = " " * 128  
  295.     size = "128"  
  296.     Win32API.new('advapi32','GetUserName',['P','P'],'I').call(name,size)
  297.     username = name.unpack("A*")
  298.     return username[0]
  299.   end  
  300.   # --------------------------------------------------------------------------
  301.   # * Restituisce la cartella utente di Windows
  302.   # --------------------------------------------------------------------------
  303.   def self.homepath
  304.     name = " " * 128  
  305.     size = "128"  
  306.     username = "\0" * 256 #userprofile
  307.     Win32API.new('kernel32', 'GetEnvironmentVariable', %w(p p l), 'l').call("userprofile", username, 256)
  308.     username.delete!("\0")
  309.     return username.gsub("\\","/")
  310.   end
  311.   # --------------------------------------------------------------------------
  312.   # * Restituisce il percorso di una cartella del computer
  313.   # --------------------------------------------------------------------------
  314.   def self.getFolderPath(symbol = :docs)
  315.     case symbol
  316.     when :user; index = 40
  317.     when :docs; index = 5
  318.     when :imgs; index = 39
  319.     when :musc; index = 13
  320.     when :vdeo; index = 14
  321.     when :strp; index = 2
  322.     when :prog; index = 38
  323.     when :appd; index = 28
  324.     else; index = 0
  325.     end
  326.     path = "\0" * 128  
  327.     Win32API.new('shell32', 'SHGetFolderPath', 'LLLLP', 'L').call(0, index, 0, 2, path)
  328.     return path.delete("\0").gsub("\\","/")
  329.   end
  330.   # --------------------------------------------------------------------------
  331.   # * Restituisce la larghezza della cornice della finestra
  332.   # --------------------------------------------------------------------------
  333.   def self.window_frame_width
  334.     return Win32API.new("user32", "GetSystemMetrics", ['I'],'I').call(7)
  335.   end
  336.   # --------------------------------------------------------------------------
  337.   # * Restituisce l'altezza della barra del titolo
  338.   # --------------------------------------------------------------------------
  339.   def self.window_title_height
  340.     return Win32API.new("user32", "GetSystemMetrics", ['I'],'I').call(4)
  341.   end
  342.   #-----------------------------------------------------------------------------
  343.   # * Elimina il file temporaneo per aggiornarlo prima di un download.
  344.   #   inserire il nome del file.
  345.   #-----------------------------------------------------------------------------
  346.   def self.temp_flush(nomefile)
  347.     if version < 6
  348.       path = homepath+"/Impostazioni locali/Temporary Internet Files"
  349.       unless File.directory?(path)
  350.         path = homepath+"/Local Settings/Temporary Internet Files"
  351.         return unless File.directory?(path)
  352.       end
  353.       fetch_folder_for_delete(path,nomefile)
  354.     else
  355.       path = homepath+"/AppData/Local/Microsoft/Windows/Temporary Internet Files/Content.IE5"
  356.       unless File.directory?(path)
  357.         path = cartella_utente_win+"/AppData/Local/Microsoft/Windows/INetCache/IE"
  358.       end
  359.       return unless File.directory?(path)
  360.       Dir.foreach(path) {|x|                        #per ogni file nel percorso
  361.         next if x == "." or x == ".."               #passa al prossimo se è ind.
  362.         if File.directory?(path+"/"+x)              #se il file è una cartella
  363.           folder = path+"/"+x                       #entra nella cartella
  364.           fetch_folder_for_delete(folder,nomefile)
  365.         end
  366.       }
  367.     end
  368.   end
  369.   # --------------------------------------------------------------------------
  370.   # * Cerca nella cartella il file da cancellare
  371.   #   path: directory
  372.   #   nomefile: file da cancellare
  373.   # --------------------------------------------------------------------------
  374.   def self.fetch_folder_for_delete(path,nomefile)
  375.     Dir.foreach(path) {|y|                  #per ogni file nella cartella
  376.       next if File.directory?(path+"/"+y)   #passa al prossimo se è una c.
  377.       if no_ext(nomefile) == y[0..no_ext(nomefile).size-1]#se l'inizio del nome corrisp.
  378.         begin
  379.           File.delete(path+"/"+y)             #eliminalo
  380.         rescue
  381.           next
  382.         end
  383.       end
  384.     }
  385.   end
  386.   # --------------------------------------------------------------------------
  387.   # * Restituisce la versione di Windows in uso
  388.   # --------------------------------------------------------------------------
  389.   def self.version
  390.     gvex = Win32API.new( 'kernel32', 'GetVersionEx', ['P'], 'I' )
  391.     s = [20+128, 0, 0, 0, 0, '' ].pack('LLLLLa128')
  392.     gvex.call( s );
  393.     a = s.unpack( 'LLLLLa128' )
  394.     indice = a[1].to_f;dec = a[2].to_f/10
  395.     return indice + dec
  396.   end
  397.   #-----------------------------------------------------------------------------
  398.   # * Restituisce il nome del file senza estensione.
  399.   #-----------------------------------------------------------------------------
  400.   def self.no_ext(nomefile)
  401.     nome = nomefile.split(".")
  402.     return nome[0]
  403.   end
  404.   #-----------------------------------------------------------------------------
  405.   # * Restituisce un array di larghezza e altezza della parte utilizzabile dello
  406.   #   schermo: non conta lo spazio della barra delle applicazioni.
  407.   #-----------------------------------------------------------------------------
  408.   def self.screen_resolution
  409.     x = Win32API.new("user32", "GetSystemMetrics", ['I'],'I').call(16)
  410.     y = Win32API.new("user32", "GetSystemMetrics", ['I'],'I').call(17)
  411.     return [x,y]
  412.   end
  413.   #-----------------------------------------------------------------------------
  414.   # * Restituisce un intero come codice della lingua del sistema
  415.   #-----------------------------------------------------------------------------
  416.   def self.language
  417.     return Win32API.new("kernel32", "GetUserDefaultLCID", [], 'I').call
  418.   end
  419.   #-----------------------------------------------------------------------------
  420.   # * Restituisce la data attuale
  421.   #-----------------------------------------------------------------------------
  422.   def self.datenow(partition = -1)
  423.     date = Time.now
  424.     case partition
  425.     when -1
  426.       return sprintf("%d/%d/%d",date.day,date.month,date.year)
  427.     when 0
  428.       return date.day
  429.     when 1
  430.       return date.month
  431.     when 2
  432.       return date.year
  433.     end
  434.   end
  435.   #-----------------------------------------------------------------------------
  436.   # * Restituisce l'ora attuale
  437.   #-----------------------------------------------------------------------------
  438.   def self.timenow(partition = -1)
  439.     date = Time.now
  440.     case partition
  441.     when -1
  442.       return sprintf("%d:%d",date.hour,date.min)
  443.     when 0
  444.       return date.hour
  445.     when 1
  446.       return date.min
  447.     when 2
  448.       return date.sec
  449.     end
  450.   end
  451.   #-----------------------------------------------------------------------------
  452.   # * arresta il computer in modalità diverse.
  453.   #-----------------------------------------------------------------------------
  454.   def self.shutdown(mode = 0)
  455.     string = "system "
  456.     case mode
  457.     when 0
  458.       string += "-s"
  459.     when 1
  460.       string += "-r"
  461.     when 2
  462.       string += "-h"
  463.     end
  464.     system(string)
  465.   end  
  466. end #win
  467.  
  468. #==============================================================================
  469. # ** Screen
  470. #------------------------------------------------------------------------------
  471. #  Questo modulo gestisce il ridimensionamento della finestra di gioco
  472. #==============================================================================
  473. module Screen
  474.   #-----------------------------------------------------------------------------
  475.   # * ridimensiona la finestra e la centra
  476.   #   width = nuova larghezza
  477.   #   height = nuova altezza
  478.   #-----------------------------------------------------------------------------
  479.   def self.resize(width ,height)
  480.     #API
  481.     getSystemMetrics = Win32API.new("user32", "GetSystemMetrics", 'I', 'I')
  482.     moveWindow = Win32API.new("user32","MoveWindow",['l','i','i','i','i','l'],'l')
  483.     findWindowEx = Win32API.new("user32","FindWindowEx",['l','l','p','p'],'i')
  484.     this_window = findWindowEx.call(0,0,"RGSS Player",0)
  485.     res_x = Win.screen_resolution[0] #risoluzione x
  486.     res_y = Win.screen_resolution[1] #risoluzione y
  487.     width += Win.window_frame_width*2
  488.     height += Win.window_frame_width*2 + Win.window_title_height
  489.     new_x = [(res_x-width)/2, 0].max #ottiene la nuova coordinata, ma non
  490.     new_y = [(res_y-height)/2, 0].max#fa passare oltre il bordo
  491.     moveWindow.call(this_window, new_x, new_y, width, height, 1)
  492.   end
  493. end #screen
  494.  
  495. #==============================================================================
  496. # ** HTTP
  497. #------------------------------------------------------------------------------
  498. #  Questo modulo permette di interfacciarsi ad internet e gestire i download.
  499. #  Ringraziamenti: Berka (il codice è ispirato al suo)
  500. #==============================================================================
  501. module HTTP  
  502.   SetPrClass = Win32API.new('kernel32','SetPriorityClass','pi','i').call(-1,128)
  503.   InternetOpenA = Win32API.new("wininet",'InternetOpenA','plppl','l').call('',0,'','',0)
  504.   InternetConnectA = Win32API.new("wininet",'InternetConnectA','lplpplll','l')
  505.   InternetOpenUrl = Win32API.new("wininet",'InternetOpenUrl','lppllp','l')
  506.   InternetReadFile = Win32API.new("wininet",'InternetReadFile','lpip','l')
  507.   InternetCloseHandle = Win32API.new("wininet",'InternetCloseHandle','l','l')
  508.   HttpQueryInfo = Win32API.new("wininet",'HttpQueryInfo','llppp','i')
  509.   #--------------------------------------------------------------------------
  510.   # * Scarica un file da internet in un thread separato
  511.   # url = indirizzo completo del nome del file
  512.   # folder = cartella dove depositare il file scaricato
  513.   #--------------------------------------------------------------------------
  514.   def self.download(url, folder = "./", low_priority = false, filename = nil, save = true)
  515.     #inizializzazione
  516.     @downloaded = 0 if @downloaded.nil?
  517.     @downloads = {} if @downloads.nil?
  518.     @counter = -1 if @counter.nil?
  519.     @size = {} if @size.nil?
  520.     @received = {} if @received.nil?
  521.     @timepassed = {} if @timepassed.nil?
  522.     @response = {} if @response.nil?
  523.     @completed = {} if @completed.nil?
  524.    
  525.     #ottenimento dell'indirizzo
  526.     address = url.split('/')
  527.     server = address[2]
  528.     root = address[3..address.size].join('/')
  529.     filename = address[-1] if filename == nil
  530.    
  531.     #crezione del thread
  532.     @downloads[filename] = Thread.start(url,folder, save){|url,folder,save|
  533.       txt = ""
  534.       t = Time.now
  535.       "Serv f" if(e=InternetConnectA.call(InternetOpenA,server,80,'','',3,1,0))==0
  536.       file = InternetOpenUrl.call(InternetOpenA,url,nil,0,0,0)
  537.       HttpQueryInfo.call(file,5,k="\0"*1024,[k.size-1].pack('l'),nil)
  538.       @received[filename] = 0
  539.       @size[filename] = k.delete!("\0").to_i
  540.       loop do
  541.         buffer = " "*1024
  542.         n = 0
  543.         r = InternetReadFile.call(file,buffer,1024,o=[n].pack('i!'))
  544.         n = o.unpack('i!')[0]
  545.         txt<<buffer[0,n]
  546.         @response[filename] = txt if !save
  547.         @received[filename] = txt.size
  548.         if r&&n==0
  549.           break
  550.         end
  551.         sleep(0.001) if low_priority
  552.       end
  553.       #creazione del file nel percorso
  554.       if save
  555.         if File.directory?(folder)
  556.           obj = File.open(folder + filename,'wb')<<txt
  557.           obj.close #chiusura del file
  558.         else
  559.           string = "%s non è un percorso valido, pertanto %s non verrà salvato."
  560.           println sprintf(string, folder, filename)
  561.         end
  562.       end
  563.       @received[filename] = @size[filename]
  564.       @completed[filename] = true
  565.       @downloaded += @received[filename]
  566.       InternetCloseHandle.call(file)
  567.       sleep(0.01)
  568.       @timepassed[filename] = Time.now-t
  569.       }
  570.   end
  571.   #--------------------------------------------------------------------------
  572.   # * Ottiene la dimensione di un file remoto in modo asincrono
  573.   #--------------------------------------------------------------------------
  574.   def self.get_file_size_async(url)
  575.     @filesize = {} if @filesize.nil?
  576.     Thread.start(url){|url|
  577.       @filesize[url] = get_file_size(url)
  578.     }
  579.   end
  580.   #--------------------------------------------------------------------------
  581.   # * Restituisce true se la dimensione del file è stata ottenuta
  582.   #--------------------------------------------------------------------------
  583.   def self.size_get?(url)
  584.     return false if @filesize.nil?
  585.     return @filesize[url] != nil?
  586.   end
  587.   #--------------------------------------------------------------------------
  588.   # * Ottiene la dimensione di un file remoto
  589.   #--------------------------------------------------------------------------
  590.   def self.get_file_size(url)
  591.     file = InternetOpenUrl.call(InternetOpenA,url,nil,0,0,0)
  592.     HttpQueryInfo.call(file,5,k="\0"*1024,[k.size-1].pack('l'),nil)
  593.     InternetCloseHandle.call(file)
  594.     return k.delete!("\0").to_i
  595.   end
  596.   #--------------------------------------------------------------------------
  597.   # * Ottiene la risposta del server e la piazza nell'array delle rispose
  598.   #   url: indirizzo della richiesta
  599.   #   response_name: nome della risposta (per poterla leggere)
  600.   #   low_priority: priorità (false se normale, true se bassa)
  601.   #--------------------------------------------------------------------------
  602.   def self.get_server_response(url, response_name, low_priority = false)
  603.     download(url, "", low_priority, response_name, false)
  604.   end
  605.   #--------------------------------------------------------------------------
  606.   # * Restituisce direttamente il testo di risposta dal server, interrompendo
  607.   #   l'esecuzione del gioco fino a quando non arriva la risposta.
  608.   #   url: indirizzo della richiesta
  609.   #--------------------------------------------------------------------------
  610.   def self.await_get_server_response(url)
  611.     response = "response"
  612.     @response.delete(response) if @response != nil
  613.     @received.delete(response) if @received != nil
  614.     @downloads.delete(response) if @downloads != nil
  615.     download(url, "", false, response, false)
  616.     loop {break if downloaded?(response)}
  617.     return @response[response]
  618.   end
  619.   class << self; alias await_response await_get_server_response; end
  620.   #--------------------------------------------------------------------------
  621.   # * Restituisce true se il file è scaricato.
  622.   # filename: nome del file
  623.   #--------------------------------------------------------------------------
  624.   def self.downloaded?(filename)
  625.     return false if @received.nil?
  626.     return false if @received[filename].nil?
  627.     return false if @size[filename].nil?
  628.     return true if @received[filename] >= @size[filename]
  629.     return true if progress(filename) >= 100
  630.     return true if progress(filename).to_s == "NaN"
  631.     return true if @completed[filename]
  632.     return false
  633.   end
  634.   #--------------------------------------------------------------------------
  635.   # * Restituisce la grandezza del file da scaricare in byte
  636.   # filename: nome del file
  637.   #--------------------------------------------------------------------------
  638.   def self.filesize(filename)
  639.     return 0 if @size.nil?
  640.     return 0 if @size[filename].nil?
  641.     return @size[filename]
  642.   end
  643.   #--------------------------------------------------------------------------
  644.   # * Restituisce la quantità di byte scaricati
  645.   # filename: nome del file
  646.   #--------------------------------------------------------------------------
  647.   def self.sizeloaded(filename)
  648.     return 0 if @received.nil?
  649.     return 0 if @received[filename].nil?
  650.     return @received[filename]
  651.   end
  652.   #--------------------------------------------------------------------------
  653.   # * Restituisce la percentuale di progresso del download
  654.   # filename: nome del file
  655.   #--------------------------------------------------------------------------
  656.   def self.progress(filename)
  657.     @received = {} if @received.nil?
  658.     return 0 if @received[filename].nil?
  659.     return @received[filename].to_f/@size[filename]*100
  660.   end
  661.   #--------------------------------------------------------------------------
  662.   # * Restituisce l'hash dei download
  663.   #--------------------------------------------------------------------------
  664.   def downloads
  665.     return {} if @downloads.nil?
  666.     return @downloads
  667.   end
  668.   #--------------------------------------------------------------------------
  669.   # * Restituisce il numero di secondi che ci sono voluti per scaricare
  670.   #--------------------------------------------------------------------------
  671.   def self.time_passed(filename)
  672.     return 0 if @timepassed[filename] == nil
  673.     return @timepassed[filename]
  674.   end
  675.   #--------------------------------------------------------------------------
  676.   # * Restituisce il numero dei download completati
  677.   #--------------------------------------------------------------------------
  678.   def self.completed
  679.     return 0 if @downloaded.nil?
  680.     return @downloaded
  681.   end
  682.   #--------------------------------------------------------------------------
  683.   # * Restituisce la risposta dal server
  684.   #   response_name: id della risposta
  685.   #--------------------------------------------------------------------------
  686.   def self.response(response_name)
  687.     return 0 if @response.nil? || @response[response_name].nil?
  688.     return @response[response_name]
  689.   end
  690.   #--------------------------------------------------------------------------
  691.   # * Restituisce i download
  692.   #--------------------------------------------------------------------------
  693.   def self.downloads
  694.     @downloads ||= {}
  695.     return @downloads
  696.   end
  697.   #--------------------------------------------------------------------------
  698.   # * Restituisce il dominio principale
  699.   #--------------------------------------------------------------------------
  700.   def self.domain
  701.     H87_ModConfig::HTTPDOMAIN
  702.   end
  703.   #--------------------------------------------------------------------------
  704.   # * Controlla se il file scaricato è buono e restituisce true o false
  705.   #--------------------------------------------------------------------------
  706.   def self.file_good?(filename)
  707.     if File.exist? (filename) #apre il file in sola lett.
  708.       File.open(filename,"r") do |f|
  709.       f.lineno = 1 # imposta la riga n.1
  710.       txt = f.gets
  711.       return check_response(txt)
  712.       end
  713.     else
  714.       return false
  715.     end
  716.   end
  717.   #--------------------------------------------------------------------------
  718.   # * Restituisce true se il testo non è vuoto
  719.   #--------------------------------------------------------------------------
  720.   def self.check_response(text)
  721.     return false if text == "" or text.nil?
  722.     first = text[0].chr
  723.     return false if first == "" or first == nil
  724.     return true
  725.   end
  726. end #http
  727.  
  728. #==============================================================================
  729. # ** Async_Downloads
  730. #------------------------------------------------------------------------------
  731. #  Dev'essere incluso nelle classi che fanno uso dei metodi download_async.
  732. #==============================================================================
  733. module Async_Downloads
  734.   #--------------------------------------------------------------------------
  735.   # * Scarica un file in modo asincrono lanciando automaticamente il metodo.
  736.   #   url:          indirizzo del file
  737.   #   method_name:  nome del metodo, in simbolo (ad es. :apri)
  738.   #   low:          true se è a bassa incidenza, false altrimenti
  739.   #   folder:       percorso del file di salvataggio
  740.   #--------------------------------------------------------------------------
  741.   def download_async(url, method, folder = "./", low = true)
  742.     filename = url.split('/')[-1]
  743.     if filename.downcase.include? ".php"
  744.       println "Questo URL chiama un file PHP, pertanto non verrà salvato."
  745.       println "Utilizzare invece il metodo get_repsonse_async."
  746.       return
  747.     end
  748.     @async_downloads = {} if @async_downloads.nil?
  749.     @async_downloads[filename] = method
  750.     HTTP.download(url, folder, low)
  751.   end
  752.   #--------------------------------------------------------------------------
  753.   # * Ottiene la risposta di un servizio web in modo asincrono, lanciando
  754.   #   automaticamente il metodo associato.
  755.   #   url:          indirizzo della richiesta
  756.   #   method_name:  nome del metodo, in simbolo (ad es. :apri)
  757.   #   low:          true se è a bassa incidenza, false altrimenti
  758.   #   response_id:  id della risposta.
  759.   #--------------------------------------------------------------------------
  760.   def get_response_async(url, method, low = true, response_id = String.random(20))
  761.     @async_responses = {} if @async_responses.nil?
  762.     @async_responses[response_id] = method
  763.     HTTP.get_server_response(url, response_id, low)
  764.   end
  765.   #--------------------------------------------------------------------------
  766.   # * Restituisce direttamente la stringa di risposta dal server
  767.   #   url: indirizzo della richiesta
  768.   #--------------------------------------------------------------------------
  769.   def await_response(url)
  770.     return HTTP.await_get_server_response(url)
  771.   end
  772.   #--------------------------------------------------------------------------
  773.   # * Controlla i download e lancia il metodo associato se completato.
  774.   #--------------------------------------------------------------------------
  775.   def check_async_downloads
  776.     return if @async_downloads.nil? || @async_downloads.size == 0
  777.     @async_downloads.each_key do |key|
  778.       if HTTP.downloaded?(key)
  779.         @async_downloads[key].call
  780.         @async_downloads.delete(key)
  781.       end
  782.     end
  783.   end
  784.   #--------------------------------------------------------------------------
  785.   # * Controlla le risposte e lancia il metodo associato quando ricevuta.
  786.   #--------------------------------------------------------------------------
  787.   def check_async_requests
  788.     return if @async_responses.nil? || @async_responses.size == 0
  789.     @async_responses.each_key do |key|
  790.       if HTTP.downloaded?(key) && HTTP.response(key) != nil
  791.         @async_responses[key].call(HTTP.response(key))
  792.         @async_responses.delete(key)
  793.       end
  794.     end
  795.   end
  796.   #--------------------------------------------------------------------------
  797.   # * Cancella un download o l'attesa di una risposta
  798.   #   filename: nome del file o id della risposta
  799.   #--------------------------------------------------------------------------
  800.   def abort_download(filename)
  801.     Thread.kill(HTTP.downloads(filename))
  802.   end
  803.   #--------------------------------------------------------------------------
  804.   # * Restituisce la percentuale di download da 0 a 100
  805.   #   filename: nome del file
  806.   #--------------------------------------------------------------------------
  807.   def download_status(filename)
  808.     status = HTTP.progress(filename)
  809.     return [[0, status].max, 100].min.to_i
  810.   end
  811. end
  812.  
  813. #==============================================================================
  814. # ** Modulo Browser per aprire il browser predefinito del PC
  815. #==============================================================================
  816. module Browser
  817.   #--------------------------------------------------------------------------
  818.   # * apre il browser
  819.   #   url: url impostato
  820.   #--------------------------------------------------------------------------
  821.   def self.open(url)
  822.     #controlla che ci siano prefissi
  823.     if url[0..6] != "http://" and url[0..7] != "https://"
  824.       open_url = "http://"+url
  825.     else
  826.       open_url = url
  827.     end
  828.     shell = Win32API.new("Shell32", "ShellExecute", ['L', 'P', 'P', 'P','P', 'L'], 'L')
  829.     Thread.new{shell.call(0, "open", open_url, 0, 0, 1)}
  830.     sleep(0.01)
  831.     SceneManager.exit
  832.   end
  833. end #browser
  834.  
  835. #==============================================================================
  836. # ** Modulo Browser per la codifica/decodifica di stringhe in Base64
  837. #==============================================================================
  838. module Base64
  839.   #--------------------------------------------------------------------------
  840.   # * Restituisce una stringa decodificata da Base64
  841.   #     string: stringa da decodificare
  842.   #--------------------------------------------------------------------------
  843.   def self.decode(string)
  844.     return string.gsub(/\s+/, "").unpack("m")[0]
  845.   end
  846.   #--------------------------------------------------------------------------
  847.   # * Restituisce una stringa codificata in Base64
  848.   #     string: stringa da codificare
  849.   #--------------------------------------------------------------------------
  850.   def self.encode(string)
  851.     return [string].pack("m")
  852.   end
  853. end #base64
  854.  
  855. #==============================================================================
  856. # ** Classe Settings (per le impostazioni comuni ai salvataggi)
  857. #==============================================================================
  858. class H87_Settings
  859.   #--------------------------------------------------------------------------
  860.   # * restituisce l'elemento corrispondente al parametro
  861.   #--------------------------------------------------------------------------
  862.   def [](param)
  863.     @settings[param]
  864.   end
  865.   #--------------------------------------------------------------------------
  866.   # * inizializzazione
  867.   #--------------------------------------------------------------------------
  868.   def initialize
  869.     @settings = {}
  870.   end
  871.   #--------------------------------------------------------------------------
  872.   # * cambia o aggiunge un elemento dell'hash
  873.   #--------------------------------------------------------------------------
  874.   def []=(param_name,value)
  875.     @settings[param_name] = value
  876.     save
  877.   end
  878.   #--------------------------------------------------------------------------
  879.   # * Registra i dati salvati
  880.   #--------------------------------------------------------------------------
  881.   def save
  882.     save_data($game_settings,DataManager.settings_path)
  883.   end
  884. end #settings
  885.  
  886. #==============================================================================
  887. # ** Game_Version
  888. #------------------------------------------------------------------------------
  889. # Questa classe è d'appoggio per gestire la versione del gioco.
  890. #==============================================================================
  891. class Game_Version
  892.   include Comparable        #per la verifica delle versioni se maggiore o minore
  893.   attr_accessor :major      #numero di major release
  894.   attr_accessor :minor      #numero di minor release
  895.   attr_accessor :build      #numero di versione build
  896.   attr_accessor :revision   #numero di revisione
  897.   #--------------------------------------------------------------------------
  898.   # * Inizializzazione
  899.   #     version_string: versione in stringa (ad es. 1.5.3.1)
  900.   #--------------------------------------------------------------------------
  901.   def initialize(version_string, starting_major = 1)
  902.     @major = starting_major
  903.     @minor = 0
  904.     @build = 0
  905.     @revision = 0
  906.     version_string.gsub!(/\s\n\r/,"")
  907.     return unless version_string =~ /[\d]+([\.[\d]]*)/
  908.     version_string = version_string.split(".")
  909.     @major = version_string[0].to_i
  910.     return if version_string[1].nil?
  911.     @minor = version_string[1].to_i
  912.     return if version_string[2].nil?
  913.     @build = version_string[2].to_i
  914.     return if version_string[3].nil?
  915.     @revision = version_string[3].to_i
  916.   end
  917.   #--------------------------------------------------------------------------
  918.   # * Restituisce la versione attuale del gioco
  919.   #--------------------------------------------------------------------------
  920.   def self.now
  921.     if File.exist?(H87_ModConfig::VERSIONFILE)
  922.       file = File.open(H87_ModConfig::VERSIONFILE,"r")
  923.       str = file.read
  924.       file.close
  925.       return Game_Version.new(str)
  926.     else
  927.       return Game_Version.new("1.0.0.0")
  928.     end
  929.   end
  930.   #--------------------------------------------------------------------------
  931.   # * Compara una versione o una stringa con se stessa
  932.   #--------------------------------------------------------------------------
  933.   def <=> other
  934.     return self <=> Game_Version.new(other) if other.is_a?(String)
  935.     return self.major <=> other.major if self.major != other.major
  936.     return self.minor <=> other.minor if self.minor != other.minor
  937.     return self.build <=> other.build if self.build != other.build
  938.     return self.revision <=> other.revision
  939.   end
  940.   #--------------------------------------------------------------------------
  941.   # * restituisce la versione in stringa
  942.   #--------------------------------------------------------------------------
  943.   def to_s
  944.     return sprintf("%d.%d.%d.%d", @major, @minor, @build, @revision)
  945.   end
  946. end #game_version
  947.  
  948. #==============================================================================
  949. # ** RPG::System -> aggiunta del metodo per la versione del gioco
  950. #==============================================================================
  951. class Game_System
  952.   #--------------------------------------------------------------------------
  953.   # * Restituisce la versione del gioco attuale
  954.   #--------------------------------------------------------------------------
  955.   def game_version
  956.     return Game_Version.now
  957.   end
  958. end #rpg_system
  959.  
  960. #==============================================================================
  961. # ** DataManager -> aggiunta dei metodi per caricare i settaggi
  962. #==============================================================================
  963. module DataManager
  964.   #--------------------------------------------------------------------------
  965.   # * alias
  966.   #--------------------------------------------------------------------------
  967.   class << self
  968.     alias h87set_load_n_db load_normal_database
  969.     alias h87set_load_b_db load_battle_test_database
  970.   end
  971.   # --------------------------------------------------------------------------
  972.   # * caricamento nd
  973.   # --------------------------------------------------------------------------
  974.   def self.load_normal_database
  975.     load_h87settings
  976.     h87set_load_n_db
  977.   end
  978.   # --------------------------------------------------------------------------
  979.   # * caricamento btd
  980.   # --------------------------------------------------------------------------
  981.   def self.load_battle_test_database
  982.     load_h87settings
  983.     h87set_load_b_db
  984.   end
  985.   # --------------------------------------------------------------------------
  986.   # * restituisce il percorso delle impostazioni
  987.   # --------------------------------------------------------------------------
  988.   def self.settings_path
  989.     H87_ModConfig::SETTINGNAME
  990.   end
  991.   #--------------------------------------------------------------------------
  992.   # * carica le impostazioni universali
  993.   #--------------------------------------------------------------------------
  994.   def self.load_h87settings
  995.     return if $game_settings
  996.     if File.exist?(settings_path)
  997.       $game_settings = load_data(settings_path)
  998.     else
  999.       $game_settings = H87_Settings.new
  1000.       save_data($game_settings,settings_path)
  1001.     end
  1002.   end
  1003. end #datamanager
  1004.  
  1005. #==============================================================================
  1006. # ** Aggiunta di alcuni metodi utili per le stringhe
  1007. #==============================================================================
  1008. class String
  1009.   #--------------------------------------------------------------------------
  1010.   # * Metodo Random: restituisce una stringa a caso
  1011.   #   size: numero di caratteri della stringa
  1012.   #--------------------------------------------------------------------------
  1013.   def self.random(size = 4)
  1014.     stringa = rand(36**size).to_s(36)
  1015.     return stringa
  1016.   end
  1017.   #--------------------------------------------------------------------------
  1018.   # * Restituisce la stessa stringa ma crittografata in ROT13
  1019.   #   http://it.wikipedia.org/wiki/ROT13
  1020.   #--------------------------------------------------------------------------
  1021.   def crypt_rot13
  1022.     return self.tr("A-Za-z", "N-ZA-Mn-za-m")
  1023.   end
  1024. end #fine della stringa
  1025.  
  1026. #==============================================================================
  1027. # ** Inclusione dei metodi asincroni in Scene_Base
  1028. #==============================================================================
  1029. class Scene_Base
  1030.   include Async_Downloads # inclusione del modulo
  1031.   #--------------------------------------------------------------------------
  1032.   # * Alias del metodo d'aggiornamento
  1033.   #--------------------------------------------------------------------------
  1034.   alias h87_module_update update unless $@
  1035.   def update
  1036.     h87_module_update
  1037.     check_async_downloads #controlla i download
  1038.     check_async_requests  #controlla le richieste
  1039.   end
  1040. end #scene_base
  1041.  
  1042. #==============================================================================
  1043. # ** Inclusione dei metodi asincroni in Window_Base
  1044. #==============================================================================
  1045. class Window_Base
  1046.   include Async_Downloads # inclusione del modulo
  1047.   #--------------------------------------------------------------------------
  1048.   # * Alias del metodo d'aggiornamento
  1049.   #--------------------------------------------------------------------------
  1050.   alias h87_module_update update unless $@
  1051.   def update
  1052.     h87_module_update
  1053.     check_async_downloads #controlla i download
  1054.     check_async_requests  #controlla le richieste
  1055.   end
  1056. end #scene_base
  1057.  
  1058. #==============================================================================
  1059. # ** Object
  1060. #------------------------------------------------------------------------------
  1061. # Metodi universali di gioco
  1062. #==============================================================================
  1063. class Object
  1064.   #--------------------------------------------------------------------------
  1065.   # * Metodo di stampa riga
  1066.   #--------------------------------------------------------------------------
  1067.   def println(*args)
  1068.     print(*args, "\n")
  1069.   end
  1070.   #--------------------------------------------------------------------------
  1071.   # * Metodi di conversione Base64
  1072.   #--------------------------------------------------------------------------
  1073.   def base64_encode(string); Base64.encode(string); end
  1074.   def base64_decode(string); Base64.decode(string); end
  1075.   #--------------------------------------------------------------------------
  1076.   # * Restituisce direttamente la stringa di risposta dal server
  1077.   #   url: indirizzo della richiesta
  1078.   #--------------------------------------------------------------------------
  1079.   def await_response(url)
  1080.     return HTTP.await_get_server_response(url)
  1081.   end
  1082. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top