Plugin

#==============================================================================
# • Plugin
#==============================================================================
# Autor: Dax
# Créditos: Masked : Me basei no script Auto Patch dele, para verificar a versão
# do arquivo.
# Versão: 1.0 &alpha
# Site: www.dax-soft.weebly.com
# Requerimento: Dax Core
#==============================================================================
# • Descrição:
#------------------------------------------------------------------------------
#   Este script permite que você adicione 'plugins' em seu jogo. Podendo-o
# atualizar o mesmo, diretamente do jogo. Sem precisar baixa-lo ou instala-lo,
# já que o script fornece essas duas opções de maneira automática.
#==============================================================================
# • Como usar:
#------------------------------------------------------------------------------
# • Para adicionar um Plugin, você deve registrá-lo. Veja abaixo como fazer
# e um exemplo. Se tiver aprendido, e não tiver necessidade do tutorial.
# Recomendo apagar o tutorial e o exemplo xD.
=begin
** Para registrar é muito simples. Você chama o método register do Plugin,
e defini nele, dentro de uma hash {} as informações.
Plugin.register({
        Você deve de definir o nome de registro do plugin.
        name:             :nome_de_registro, # Deste modo.
        Você deve de definir o autor do plugin.
        author:           "Autor", # Desta maneira.
        Você deve de definir a versão do plugin. Para fazer baixar, caso não tenha o
        mesmo, basta por a versão 0.0.
        version:          1.0,
        Você deve de definir o link do plugin, onde o mesmo será baixado.
  link:             "url do link"
})
** Agora, no LINK em que você definir, deve conter o seguinte.
version
link<>filename<>path

  * version : A versão do plugin. Defina uma, caso você tem uma nova versão para
  o mesmo, vá no link e o edite. Mude para a mais recente versão.
  * link : URL do Link que será baixado.
  * filename : Nome do arquivo do destino.
  * path : É opcional, caso não queira, não precisa definir esta parte. Aqui você
  define a pasta para qual o arquivo irá. Lembre-se, a pasta vai estar dentro
  da pasta Data/Plugins

** Utilize o préfixo. [ROOTPATH] para definir que será somente esse arquivo
a ser lido.

Exemplo:
www.link.com/file.ext<>file.ext<>Test
ou
[ROOTPATH]www.link.com/file.ext<>file.ext<>Test

** Definindo uma imagem para ser baixado.
 Você vai seguir o mesmo esquema do de cima, porém você só irá incluir o
 pré-fixo [PICTURE] : Veja abaixo.

[PICTURE]www.link.com/file.ext<>file.ext<>Test
  No caso de definir que é imagem. O arquivo será enviado para a pasta Graphics.
Então a pasta será definida como Graphics.

** Definindo um áudio para ser baixado. Segue-se o mesmo esquema que definir
uma imagem. Você deve por o préfixo [AUDIO], e o arquivo será enviado para a
pasta Audio. Aí você definide no [path] se será BGM/BGS/ME/SE veja abaixo um exemplo
[AUDIO]www.link.com/audio.mp3<>audio.mp3<>BGM

** Definindo um arquivo para a pasta System. DLL etc. O mesmo esquema que os
demais. Você deve por o préfixo [SYSTEM], e o arquivo será enviado para a
pasta System.
[SYSTEM]www.link.com/test.dll<>test.dll

** Definindo um vídeo para ser baixado. Préfixo [MOVIE], o arquivo será enviado
para a pasta Movies
[MOVIE]www.link.com/movie.wma<>movie.wma

** Definido um arquivo para a pasta do projeto. Préfixo [PROJECT], o arquivo
será enviado para a pasta do projeto.
[PROJECT]www.link.com/readme.txt<>readme.txt

*** Veja abaixo um exemplo.
Plugin.register({
  name:         :hello_world,
  author:       "dax",
  version:      0.0,
  link:         "http://pastebin.com/raw.php?i=iAkNjUm1"
})

 No LINK do registro acima. Eu defini dá seguinte maneira. Se você abri-lo, estará
assim.
        1.2
        http://pastebin.com/download.php?i=B1geBDHK<>hello_word.rb
 ** Podemos ver a versão. 1.1. Ou seja, como registramos com a versão 0.0. O
 Plugin será baixado e o registro será atualizado com a nova versão.
 ** Podemos ver o link do o que será baixado. E logo após o mesmo, podemos ver
 o nome do arquivo de destino.

=end
#==============================================================================
# • Versões:
#------------------------------------------------------------------------------
# 0.1 : &alpha
#   - Método de registro, do script.
#   - Método para carregar e executar arquivos.
#   - Método para baixar arquivos.
# 0.5 : &beta
#   - Método para baixar arquivos e envia-los para pastas diferentes.
#   - Salvar registro.
# 1.0 :
#   - Primeira versão completa.
#==============================================================================
Dax.register(:plugin, "dax", 1.0) {
#==============================================================================
# • Plugin
#==============================================================================
module Plugin
  #----------------------------------------------------------------------------
  # • Extender & Incluir
  #----------------------------------------------------------------------------
  include API
  extend self
  #----------------------------------------------------------------------------
  # • Constantes
  #----------------------------------------------------------------------------
  MESSAGE_ZERO = "Você deseja baixar o plugin: <%s>, do autor: <%s>, versão: <%03s>"
  MESSAGE_NOZERO = "Uma nova atualização está disponível, do plugin: <%s>, do autor: <%s>, versão: <%03s>\n Você deseja baixá-la?"
  FORMAT = MessageBox::ICONINFORMATION|MessageBox::YESNO
  #----------------------------------------------------------------------------
  # • Variáveis.
  #----------------------------------------------------------------------------
  @@register = {}
  @@download = {}
  @@root_path = {}
  @check_exit = false
  #----------------------------------------------------------------------------
  # • Executar
  #----------------------------------------------------------------------------
  def run()
    self.check
    return unless @check_exit
    msgbox("<Atualização> : O jogo será fechado para conclusão.")
    exit
  end
  #----------------------------------------------------------------------------
  # • Registrar plugin.
  #----------------------------------------------------------------------------
  def register(hash)
    error_(hash)
    return if registred?(hash[:name], hash[:author], hash[:version])
    @@register[[hash[:name], hash[:author]]] = hash
    @@root_path[[hash[:name], hash[:author]]] = []
    @@download[[hash[:name], hash[:author]]] = []
  end
  #----------------------------------------------------------------------------
  # • Verificar se já está registrado.
  #----------------------------------------------------------------------------
  def registred?(key, author, version=nil, compare=:>=)
    if @@register.has_key?([name, author])
      return true if version.nil?
      return !(@@register[[name, author]].get(:version) { |_version| version.method(compare).call(_version) } ).nil?
    else
      return false
    end
  end
  #----------------------------------------------------------------------------
  # • Obter informações.
  #----------------------------------------------------------------------------
  def info(key, author, version=nil)
    return if registred?(key, author, version)
    @@register[[key, author]]
  end
  #----------------------------------------------------------------------------
  # • Carrega tudo.
  #----------------------------------------------------------------------------
  def load_all
    load_register if FileTest.exist?("#{Dir.pwd}/Data/register.rvdata2") && !$TEST
    @@root_path.each_value { |value|
      if value.is_a?(String)
        load_script(value.strip) rescue next
      elsif value.is_a?(Array)
        value.each { |path| load_script(path) rescue next } rescue next
      end
    }
  end
protected
  #----------------------------------------------------------------------------
  # • Checar se é necessário atualizar.
  #----------------------------------------------------------------------------
  def check
    return unless $TEST
    return puts("Sem conexão com à internet.") unless Network.connected?
    load_register if FileTest.exist?("#{Dir.pwd}/Data/register.rvdata2")
    @@register.each_pair { |key, value|
      temp = "#{Dir.pwd}/temp.tmp"
      Network.link_download(value.get(:link), temp)
      File.open(temp, "rb") { |file| @@download[[*key]] = file.read.split(/\n/) }
      version = @@download[[*key]].shift.to_f
      if value.get(:version) == 0.0
        _msg = sprintf(MESSAGE_ZERO, value.get(:name), value.get(:author), version)
        hresult = MessageBox.call("Plugin Message", _msg, FORMAT)
      elsif version > value.get(:version)
        @@root_path[[*key]].clear
        _msg = sprintf(MESSAGE_NOZERO, value.get(:name), value.get(:author), version)
        hresult = MessageBox.call("Plugin Message", _msg, FORMAT)
      end
      if hresult == MessageBox::YES
        catch(:loop) {
          @@download[[*key]].each_with_index { |__download__, n|
            __download__ = __download__.sub(/\r|\n/, "")
            if __download__.include?("[PICTURE]")
              __download__ = __download__.sub("[PICTURE]", "")
              download(__download__, key, "./Graphics/", true)
            elsif __download__.include?("[AUDIO]")
              __download__ = __download__.sub("[AUDIO]", "")
              download(__download__, key, "./Audio/", true)
            elsif __download__.include?("[SYSTEM]")
              __download__ = __download__.sub("[SYSTEM]", "")
              download(__download__, key, "./System/", true)
            elsif __download__.include?("[MOVIE]")
              __download__ = __download__.sub("[MOVIE]", "")
              download(__download__, key, "./Movies/", true)
            elsif __download__.include?("[PROJECT]")
              __download__ = __download__.sub("[PROJECT]", "")
              download(__download__, key, "./", true)
            elsif __download__.include?("[ROOTPATH]")
              __download__ = __download__.sub("[ROOTPATH]", "")
              download(__download__, key, "./Data/Plugins/", false, true)
            else
              download(__download__, key)
            end
          }
          throw(:loop)
        }
      end
      @@register[[*key]][:version] = version
      File.delete(temp)
      save_register
    }
  end
  #----------------------------------------------------------------------------
  # • Verificar erros
  #----------------------------------------------------------------------------
  def error_(hash)
    return unless hash.is_a?(Hash)
    raise("Error Plugin Register : name not defined") if hash[:name].nil?
    raise("Error Plugin Register : author not defined") if hash[:author].nil?
    raise("Error Plugin Register : version not defined") if hash[:version].nil?
    raise("Error Plugin Register : link not defined") if hash[:link].nil?
  end
  #----------------------------------------------------------------------------
  # • Baixar
  #----------------------------------------------------------------------------
  def download(content, key, dir="./Data/Plugins/", noexec=false, rootpath=false)
    @check_exit = true
    data = content.split(/<>/)
    path = dir
    unless data[2].nil?
      path << data[2]
      path << "/" unless data[2].include?("/")
    end
    Dir.mkdir(path) unless FileTest.directory?(path)
    _name = data[1]
    Network.link_download(data[0], path + _name)
    sleep(0.1)
    if rootpath
      @@root_path[[*key]] = path + _name
    elsif @@root_path[[*key]].is_a?(Array)
      @@root_path[[*key]] << path + _name unless noexec
    end
  end
  #----------------------------------------------------------------------------
  # • Salvar configuração dos registro.
  #----------------------------------------------------------------------------
  def save_register
    File.open("#{Dir.pwd}/Data/register.rvdata2", "wb") { |file|
      export = -> {
        content = {}
        content[:register] = @@register
        content[:root_path] = @@root_path
        content
      }
      Marshal.dump(export.call, file)
    }
  end
  #----------------------------------------------------------------------------
  # • Carregar registro.
  #----------------------------------------------------------------------------
  def load_register
    File.open("#{Dir.pwd}/Data/register.rvdata2", "rb") { |file|
      import = ->(content) {
        @@register.merge!(content[:register]) rescue {}
        @@root_path.merge!(content[:root_path]) rescue {}
      }
      import[Marshal.load(file)]
    }
  end
end
#==========================================================================
# • Insira aqui: Os Registros dos plugin.
#==========================================================================

Plugin.register({
   name:         :hello_world,
   author:       "dax",
   version:      0.0,
   link:         "http://pastebin.com/raw.php?i=iAkNjUm1"
})

#==========================================================================
# • Não mexa aqui.
#==========================================================================
$ROOT_PATH = ->(filename, dir="") { "#{Dir.pwd}/Data/Plugins/#{dir}#{filename}" }
Plugin.run
Plugin.load_all
}