MBS - DLC

#==============================================================================
# MBS - DLC
#------------------------------------------------------------------------------
# por Masked
#==============================================================================
#==============================================================================
# Instruções
#------------------------------------------------------------------------------
# Criando o projeto:
#------------------------------------------------------------------------------
#    Para criar uma DLC, primeiro crie um novo projeto no RPG Maker e faça tudo
#  normalmente, não é preciso colocar no projeto da DLC o conteúdo já existente
#  na versão original do jogo, e lembre-se de criar as coisas no database com o
#  ID a partir do último ID já usado no jogo.
#
#    Por questão de segurança, deixe, na versão original do jogo, todos os
#  primeiros espaços do database vazios.
#
#  (OBS.: Para fazer os mapas, recomendo que os faça no projeto original e
#  depois passe tudo que foi criado ou alterado para o projeto da DLC, assim
#  o ID do mapa não fica igual ao de outro mapa)
#
#    Lembre-se também que, exceto os mapas, todos os elementos da DLC são
#  "somados" aos originais.
#    No caso dos mapas, todo mapa que existir na DLC vai substituir qualquer
#  mapa que tenha o mesmo ID.
#
#------------------------------------------------------------------------------
# Exportando a DLC:
#------------------------------------------------------------------------------
#    Para exportar a DLC, coloque num script acima do main:
#      MBS::DLC.export(nome, itens_exportados, encriptar, chave)
#
#    Nesse caso, nome deve ser o nome do arquivo da DLC a ser criada, e deve
#  vir entre aspas, e itens exportados deve ser uma Array com a lista de itens
#  que a DLC vai ter, existem algumas listas prontas que podem ser usadas,
#  elas são:
#
#    - MBS::DLC::ALL       = Exporta tudo que for possível
#
#    - MBS::DLC::ALL_DATA  = Exporta tudo exceto as pastas Graphics e Audio
#
#    - MBS::DLC::MAPS      = Exporta todos os mapas, dados dos mapas,
#                            tilesets e eventos comuns
#
#    - MBS::DLC::BATTLERS  = Exporta heróis, habilidades, animações, inimigos,
#                            tropas, estados, classes, itens, armas e armaduras
#
#    - MBS::DLC::ITEMS     = Exporta itens, armas e armaduras
#
#    - MBS::DLC::USABLE    = Exporta itens e habilidades
#
#    - MBS::DLC::RESOURCES = Exporta gráficos, audio e scripts
#
#    Além dessas listas pré-definidas, podem ser feitas outras listas, usando
#   para isso os seguintes itens precedidos por : (dois pontos):
#
#    - maps
#    - tilesets
#    - c_events
#    - map_data
#    - items
#    - weapons
#    - armors
#    - skills
#    - actors
#    - classes
#    - enemies
#    - troops
#    - states
#    - animations
#    - system
#    - scripts
#    - graphics
#    - audio
#
# 'Encriptar' deve ser true, para encriptar, e false, para não encriptar, a
# encriptação exige o script MS - Crypt no projeto.
# A chave pode ser um texto ou um número.
#------------------------------------------------------------------------------
#   Ex.:
#------------------------------------------------------------------------------
#
#  # exporta tudo, encriptando com a senha 'maçã'
#  MBS::DLC.export('dlc1', MBS::DLC::ALL, true, 'maçã')
#
#  # exporta itens, animações, estados e scripts encriptando com a senha 123345
#  MBS::DLC.save('dlc2', [:items, :animations, :states, :scripts], true, 12345)
#
#------------------------------------------------------------------------------
# Colocando a DLC no jogo
#------------------------------------------------------------------------------
#   Para colocar a DLC no jogo, é só copiar o arquivo que aparece depois de
# exportar a DLC (algumacoisa.rvdlc2) na pasta do jogo, com isso, o script
# carrega os dados do arquivo junto com o resto.
#   Caso queira importar todas as DLCs disponíveis automaticamente, coloque
# num script acima do main:
#
# MBS::DLC.import_all(encriptar, chave)
#
# Trocando encriptar por true (caso as DLCs estejam encriptadas) ou por false
# (caso não) e chave pela chave de encriptação usada nas DLCs (pode ser um
# texto entre aspas ou um número)
#
# Para importar uma DLC separadamente:
# MBS::DLC.import(nome, encriptar, chave)
#
# Trocando nome pelo nome do arquivo sem a extensão e encritar e chave como no
# import_all
#==============================================================================
($imported ||= {})[:mbs_dlc] = true
#==============================================================================
# >> MBS
#------------------------------------------------------------------------------
# Este é o módulo básico dos scripts MS/MBS
#==============================================================================
module MBS
  #============================================================================
  # >> DLC
  #----------------------------------------------------------------------------
  # Este é o módulo de importação e exportação da DLC
  #============================================================================
  module DLC
    #==========================================================================
    # Configurações
    #==========================================================================

    # Extensão do arquivo de DLC
    EXTENSION = 'rvdlc2'

    # Opção padrão para encriptar ou não os arquivos de DLC
    ENCRYPT = false

    # Chave de encriptação padrão
    CRYPT = ''

    #==========================================================================
    # Fim das configurações
    #==========================================================================

    # Variável com os dados das DLCs
    @@data = {}

    #==========================================================================
    # << @@data
    #--------------------------------------------------------------------------
    # Esta é a classe singleton da variável @@data
    #==========================================================================
    class << @@data
      #------------------------------------------------------------------------
      # * Aquisição do valor em um índice
      #------------------------------------------------------------------------
      def [](index)
        if index.nil?
          return values.inject({}) do |r, v|
            r.merge(v)
          end
        else
          return super(index)
        end
      end
    end

    #--------------------------------------------------------------------------
    # * Aquisição dos dados de uma DLC
    #--------------------------------------------------------------------------
    def self.data(dlc)
      @@data[dlc] || {}
    end

    #==========================================================================
    # ** DLCExportError
    #--------------------------------------------------------------------------
    # Esta é a classe dos erros no salvamento das DLCs
    #==========================================================================
    class DLCExportError < RuntimeError
      #------------------------------------------------------------------------
      # * Inicialização do objeto
      #------------------------------------------------------------------------
      def initialize(dlcname, parenterror)
        super("Erro ao exportar DLC '#{dlcname}' (#{parenterror.class})")
      end
    end

    #==========================================================================
    # ** DLCLoadError
    #--------------------------------------------------------------------------
    # Esta é a classe dos erros no carregamento das DLCs
    #==========================================================================
    class DLCLoadError < RuntimeError
      #------------------------------------------------------------------------
      # * Inicialização do objeto
      #------------------------------------------------------------------------
      def initialize(dlcname, parenterror)
        super("Erro ao carregar DLC '#{dlcname}' (#{parenterror.class})")
      end
    end

    #==========================================================================
    # ** DLCCryptError
    #--------------------------------------------------------------------------
    # Esta é a classe dos erros com a encriptação das DLCs
    #==========================================================================
    class DLCCryptError < RuntimeError
      #------------------------------------------------------------------------
      # * Inicialização do objeto
      #------------------------------------------------------------------------
      def initialize
        super("O script MBS - DLC requer o script MS - Crypt para " +
              "encriptar os arquivos de DLC")
      end
    end

    #--------------------------------------------------------------------------
    # Constantes
    #--------------------------------------------------------------------------

    # Todos os componentes possíveis para a DLC
    ALL = [
            :maps,      :c_events,   :actors,    :classes,  :items,
            :weapons,   :armors,     :skills,    :enemies,  :troops,
            :states,    :animations, :tilesets,  :system,   :graphics,
            :audio,     :scripts,    :map_info
          ]

    # Todos os componentes da DLC relacionados a dados
    ALL_DATA = ALL - [:audio, :graphics]

    # Todos os componentes da DLC relacionados a itens
    ITEMS = [:items, :weapons, :armors]

    # Todos os components da DLC relacionados à batalha
    BATTLERS = [:actors, :classes, :skills,     :armors, :weapons, :enemies,
                :troops, :states,  :animations, :items]

    # Todos os componentes da DLC relacionados a itens usáveis
    USABLE = [:skills, :items]

    # Todos os componentes da DLC relacionados aos mapas
    MAPS = [:maps, :c_events, :tilesets, :map_info]

    # Todos os componentes da DLC relacionados aos recursos
    RESOURCES = [:graphics, :audio, :scripts]

    # Tabela associativa dos símbolos dos componentes com seus respectivos
    # arquivos/pastas
    FILES = {
      maps:       'Data/Map%03d.rvdata2',
      c_events:   'Data/CommonEvents.rvdata2',
      actors:     'Data/Actors.rvdata2',
      classes:    'Data/Classes.rvdata2',
      items:      'Data/Items.rvdata2',
      weapons:    'Data/Weapons.rvdata2',
      armors:     'Data/Armors.rvdata2',
      skills:     'Data/Skills.rvdata2',
      enemies:    'Data/Enemies.rvdata2',
      troops:     'Data/Troops.rvdata2',
      states:     'Data/States.rvdata2',
      animations: 'Data/Animations.rvdata2',
      tilesets:   'Data/Tilesets.rvdata2',
      system:     'Data/System.rvdata2',
      graphics:   'Graphics',
      audio:      'Audio',
      scripts:    'Data/Scripts.rvdata2',
      map_info:   'Data/MapInfos.rvdata2'
    }

    #--------------------------------------------------------------------------
    # * Exportação de uma DLC
    #--------------------------------------------------------------------------
    def self.export(name, content=ALL, encrypt=ENCRYPT, crypt=CRYPT)
      pack(name, content)
      if encrypt
        raise(MBSCryptError.new) unless $imported[:mbs_crypt]
        MBS::Crypt.encrypt_file(name + '.' + EXTENSION, crypt)
      end
    end

    #--------------------------------------------------------------------------
    # * Importação de uma DLC
    #--------------------------------------------------------------------------
    def self.import(name, encrypted=ENCRYPT, crypt=CRYPT)
      return unless FileTest.file?(name + '.' + EXTENSION)
      begin
        content = File.open(name + '.' + EXTENSION, 'rb') do |f|
          c = f.read
          if encrypted
            raise(MBSCryptError.new) unless $imported[:mbs_crypt]
            c = Zlib::Inflate.inflate(MBS::Crypt.decrypt(c, crypt))
          end
          Zlib::Inflate.inflate(c)
        end
        @@data[name] = Marshal.load(content)
      rescue
        raise DLCLoadError.new(name, $!)
      end
    end

    #--------------------------------------------------------------------------
    # * Importação de todas as DLCs possíveis
    #--------------------------------------------------------------------------
    def self.import_all(encrypted=ENCRYPT, crypt=CRYPT)
      (Dir.entries('.') - ['.', '..']).collect do |entry|
        entry =~ /(.*)\.#{EXTENSION}/
        $1
      end.compact.each do |dlc|
        import(dlc, encrypted, crypt)
      end
    end

    #--------------------------------------------------------------------------
    # * Empacotamento dos arquivos da DLC
    #--------------------------------------------------------------------------
    def self.pack(name, content)
      hash = {}
      content.each do |symbol|
        case symbol
        when :maps
          hash[symbol] = []
          Dir.entries('Data').select do |e|
            e =~ /^Map(\d+)\.rvdata2$/
          end.size.times do |i|
            hash[symbol][i] = load_data(sprintf(FILES[symbol], i + 1))
          end
        when :graphics, :audio
          hash[symbol] = {}
          entries = get_entries(FILES[symbol])
          entries.each do |filename|
            File.open(FILES[symbol] + '/' + filename, 'rb') do |file|
              index = filename.split('.')[0...-1].inject('') {|r, v| r + v}
              hash[symbol][index] = Zlib::Deflate.deflate(file.read)
            end
          end
        else
          hash[symbol] = load_data(FILES[symbol])
        end
      end
      File.open(name + '.' + EXTENSION, 'wb') do |file|
        file.write(Zlib::Deflate.deflate(Marshal.dump(hash)))
      end
    end
    private_class_method :pack

    #--------------------------------------------------------------------------
    # * Aquisição da lista de arquivos em uma pasta e suas subpastas
    #--------------------------------------------------------------------------
    def self.get_entries(foldername)
      return (Dir.entries(foldername) - ['.', '..']).inject([]) do |r, v|
        if FileTest.file?(foldername + '/' + v)
          r << v
        elsif FileTest.directory?(foldername + '/' + v)
          r += get_entries(foldername + '/' + v).collect {|f| v + '/' + f}
        end
        r
      end
    end
    private_class_method :get_entries

    #--------------------------------------------------------------------------
    # * Carregamento de um arquivo da DLC
    #--------------------------------------------------------------------------
    def self.load(file, dlc=nil)
      if FILES.values.include?(file)
        @@data[dlc][FILES.keys[FILES.values.index(file)]]
      elsif file =~ /^Data\/Map(\d+)\.rvdata2$/
        @@data[dlc][:maps][$1.to_i-1]
      elsif file =~ /^(Graphics|Audio)\/(.*)/
        Zlib::Inflate.inflate(@@data[dlc][$1.downcase.to_sym][$2])
      else
        return false
      end
    end

    #--------------------------------------------------------------------------
    # * Carregamento de um Bitmap da DLC
    #--------------------------------------------------------------------------
    def self.load_bitmap(file, dlc=nil)
      rnd = rand(0xFFFFFFFFFFFFFFFF).to_s(16)
      File.open(rnd, 'wb') do |f|
        f.write(load(file, dlc))
      end
      begin
        b = Bitmap.new(rnd)
      ensure
        File.delete(rnd)
      end
      return b
    end

    #--------------------------------------------------------------------------
    # * Execução de uma BGM
    #--------------------------------------------------------------------------
    def self.play_bgm(file, dlc=nil, vol=100, pitch=100, pos=0)
      return if RPG::BGM.last.name == file
      File.open(file, 'wb') do |f|
        f.write(load(file, dlc))
      end
      Audio.bgm_play(file, vol, pitch, pos)
    end

    #--------------------------------------------------------------------------
    # * Execução de uma BGS
    #--------------------------------------------------------------------------
    def self.play_bgs(file, dlc=nil, vol=100, pitch=100, pos=0)
      return if RPG::BGS.last.name == file
      File.open(file, 'wb') do |f|
        f.write(load(file, dlc))
      end
      Audio.bgs_play(file, vol, pitch, pos)
    end

    #--------------------------------------------------------------------------
    # * Execução de uma ME
    #--------------------------------------------------------------------------
    def self.play_me(file, dlc=nil, vol=100, pitch=100)
      unless FileTest.file?(file)
        File.open(file, 'wb') do |f|
          f.write(load(file, dlc))
        end
      end
      Audio.me_play(file, vol, pitch)
    end

    #--------------------------------------------------------------------------
    # * Execução de uma SE
    #--------------------------------------------------------------------------
    def self.play_se(file, dlc=nil, vol=100, pitch=100)
      unless FileTest.file?(file)
        File.open(file, 'wb') do |f|
          f.write(load(file, dlc))
        end
      end
      Audio.se_play(file, vol, pitch)
    end
  end
end

#==============================================================================
# >> Audio
#------------------------------------------------------------------------------
# Este é o módulo responsável pelo áudio do jogo
#==============================================================================
module Audio
  #----------------------------------------------------------------------------
  # Alias
  #----------------------------------------------------------------------------
  class << self
    alias mbsplbgm bgm_play
    alias mbsplbgs bgs_play
    alias mbsplme  me_play
    alias mbsplse  se_play
  end

  #----------------------------------------------------------------------------
  # * Tocamento de uma BGM
  #----------------------------------------------------------------------------
  def self.bgm_play(*args, &block)
    bgm_play(*args, &block) rescue MBS::DLC.play_bgm(*args)
  end

  #----------------------------------------------------------------------------
  # * Tocamento de uma BGS
  #----------------------------------------------------------------------------
  def self.bgm_play(*args, &block)
    bgs_play(*args, &block) rescue MBS::DLC.play_bgs(*args)
  end

  #----------------------------------------------------------------------------
  # * Tocamento de uma ME
  #----------------------------------------------------------------------------
  def self.bgm_play(*args, &block)
    me_play(*args, &block) rescue MBS::DLC.play_me(*args)
  end

  #----------------------------------------------------------------------------
  # * Tocamento de uma SE
  #----------------------------------------------------------------------------
  def self.bgm_play(*args, &block)
    se_play(*args, &block) rescue MBS::DLC.play_se(*args)
  end
end

#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
# Esta é a classe dos bitmaps
#==============================================================================
class Bitmap

  #----------------------------------------------------------------------------
  # Alias
  #----------------------------------------------------------------------------
  class << self
    alias mbsbmpnew new
  end

  #----------------------------------------------------------------------------
  # * Criação de um novo objeto Bitmap
  #----------------------------------------------------------------------------
  def self.new(*args, &block)
    mbsbmpnew(*args, &block) rescue MBS::DLC.load_bitmap(*args)
  end
end

#==============================================================================
# >> Built-in
#------------------------------------------------------------------------------
# Estes são os valores/métodos que podem ser usados de qualquer lugar
#==============================================================================
#------------------------------------------------------------------------------
# Alias
#------------------------------------------------------------------------------
alias mbslddt load_data

#------------------------------------------------------------------------------
# * Carregamento de dados
#------------------------------------------------------------------------------
def load_data(*args)
  d = (MBS::DLC.load(*args) rescue nil)
  return d if d
  return mbslddt(*args)
end