View difference between Paste ID: 53gEjbAs and HLZW8tuu

 #==============================================================================
 # * Dax Core
 #==============================================================================
 # Autor : Dax Aquatic X
-# Versão : Core i2.7
+# Versão : Core i2.8
 # Site : www.dax-soft.weebly.com
 # Suporte : [email protected]
 #==============================================================================
 #  Um Core com vários módulos e métodos que facilitará na hora de programar os
 # seus scripts, bom proveito.
 #==============================================================================
 # Conteúdo :
 #==============================================================================
 # i :
 #   - API
 #   - String
 #   - Integer
 #   - Float
 #   - Color
 #   - ColorBasic
 #   - DMath
 #   - Key
 #   - Mouse
 #   - Entries
 #   - Rpg Module
 #   - Read
 #   - DRGSS
 #   - Rect
 #   - Sprite
 #   - Bitmap : method (save) by Gab!
 #   - Object
 #   - Touch_Picture
 #   - Simple_Touch_Picture
 #   - Sprite_Text
 #   - Text_Base
 #   - Touch_Icon
 #   - Simple_Touch_Icon
 #   - Touch_Text
 #   - Simple_Touch_Text
 #   - Opacity
 #   - DString
 #   - Background
 #   - Window_Base
 #   - Map
 #   - VS
 #   - Sound Base
 #   - Disable Script
 #   - Regexp Symbols
 #   - Enumerables
 #   - Cache
 #   - Sprite_Icon
 #   - Module
 #   - Window_CommandEx
 #   - Crypt
 #   - Vector
 #   - Matrix
 #   - Animation(BASE para estudos.)
 #   - Sprite_Anime_Horz(BASE para estudos.)
 #   - Sprite_Anime_Vert(BASE para estudos.)
 #   - KeyStringSprite(BASE para estudos.)
-#   - Vibrator(BASE para estudos.)
+
-#   - Sprite_Vibrator(BASE para estudos.)
+
 # • TAGS : Para facilitar a localização dos códigos e explicações. Para acessar
 # o comando para localizar, basta apertar Ctrl+F.
 #==============================================================================
 # :api -> Ir até módulos das API;
 # :enumerables -> Ir até add-ons para Enumerables.
 # :string -> Ir até add-ons para a classe String.
 # :integer -> Ir até add-ons para a classe Integer.
 # :float -> Ir até add-ons para a classe Float.
 # :color -> Ir até add-ons para a classe Color.
 # :rect -> Ir até add-ons para a classe Rect.
 # :dmath -> Ir até o módulo DMath.
 # :colorbasic -> Ir até o módulo ColorBasic.
 # :key -> Ir até o módulo Key.
 # :sprite -> Ir até add-ons para a classe Sprite.
 # :bitmap -> Ir até add-ons para a classe Bitmap.
 # :mouse -> Ir até o módulo Mouse.
 # :object -> Ir até add-ons para a classe Object.
 # :entries -> Ir até a classe Entries.
 # :text_base -> Ir até a classe Text Base.
 # :drgss -> Ir até o módulo DRGSS.
 # :outline_fill_rect -> Ir até a classe OutlineFillRect
 # :backupsystem -> Ir até o método de backup. Para fazer backup só chamar o
 # método backup.
 # :dstring -> Ir até o módulo DString.
 # :scenemanager -> Ir até add-ons para o módulo SceneManager.
 # :sprite_text -> Ir até a classe Sprite_Text.
 # :opacity -> Ir até o módulo Opacity.
 # :rpg -> Ir até o módulo Rpg.
 # :shortcut -> Ir até o método Shortcut.
 # :read -> Ir até o módulo Read.
 # :background -> Ir até o módulo Background.
 # :window_base -> Ir até add-ons para a classe Window_Base.
 # :map -> Ir até o módulo Map.
 # :vs -> Ir até o módulo VS.
 # :sound_base -> Ir até o módulo Sound_Base.
 # :position -> Ir até a classe Positions.
 # :cache -> Ir até add-ons para o módulo Cache.
 # :sprite_icon -> Ir até a classe Sprite_Icon.
 # :wcEx -> Ir até a classe Window_CommandEx
 # :crypt -> Ir até o módulo Crypt.
 # :vector -> Ir até a classe Vector
 # :matrix -> Ir até a classe Matrix.
 # :animation -> Ir até o módulo de Animation.
 # :sprite_anime_horz -> Ir até a classe Sprite_Anime_Horz
 # :sprite_anime_vert -> Ir até a classe Sprite_Anime_Vert
 # :key_string_sprite -> Ir até a classe KeyStringSprite
 # :clipboard -> Ir até o módulo Clipboard
 #==============================================================================
-# :vibrator -> Ir até o módulo Vibrator
+
-# :sprite_vibrator -> Ir até a classe Sprite_Vibrator
+
 module Dax
   extend self
   #----------------------------------------------------------------------------
   #   Ajuste aqui as configurações básicas da fonte padrão do jogo.
   #----------------------------------------------------------------------------
   Font.default_name = "Trebuchet MS" # Nome padrão da fonte do jogo.
   Font.default_size = 22 # Tamanho padrão da fonte do jogo.
   Font.default_bold = true # true - Para usar negrito | false - para não usar.
   Font.default_italic = false # true - Para usar italico | false - para não usar.
   Font.default_shadow = false # true - Para usar sombra na fonte | false - para não usar.
   Font.default_outline = false # true - Para usar borda da fonte | false - para não usar.
   Font.default_out_color = Color.new(0, 0, 0) # Cor da fonte padrão da borda da fonte.
   Font.default_color = Color.new(255, 255, 255) # Cor da fonte padrão.
   FontArray = ["name", "size", "bold", "italic", "shadow", "outline", "color"]
   #----------------------------------------------------------------------------
   # * Constantes e variáveis
   #----------------------------------------------------------------------------
   @register = {} # Armazena os scripts criados que foram registrados.
   @benchmark = "" # Armazena os testes conclusos de benchmark.
   #  A imagem do ícone do Mouse tem que estar na pasta System. Basta você
   # por o nome da imagem dentro das áspas. Caso você queira usar um ícone
   # do Rpg Maker no lugar de uma imagem, basta você por o id do ícone no lugar
   # das áspas.
   Mouse_Name = ""
   #----------------------------------------------------------------------------
   # * Somente executará o bloco caso estiver registrado o script.
   #----------------------------------------------------------------------------
   # Exemplo:
   #  Dax.required_script(:teste) { # Só irá executar caso estiver registrado.
   #    methods...
   #  }
   #----------------------------------------------------------------------------
   def required_script(symbol, &block)
     block.call if @register.has_key?(symbol) and block_given?
   end
   #----------------------------------------------------------------------------
   # * Método de registrar scripts :
   #----------------------------------------------------------------------------
   # ** Este método tem de ser definido alguns valores como :
   #     symbol - nome do script, que é posto em símbolo : Ex - :arrow
   #     name - nome do autor do script, que é posto em áspas
   #     version - versão do script;
   #     data - data do script;
   #  Dax.register(symbol, name, version, data)
   # ** Você pode usá-lo para somente registrar o nome do script.
   #  Dax.register(symbol)
   #----------------------------------------------------------------------------
   def register(*args)
     if @register.has_key?(args[0])
       @register[args[0]][:version] = args[1]
       @register[args[0]][:data] = args[2]
     else
       @register[args[0]] = {name: args[1], version: args[2], data: args[3], script: nil}
     end
   end
   #----------------------------------------------------------------------------
   # * Método de verificar se o objeto existe.
   #----------------------------------------------------------------------------
   # Dax.required_class("Objeto") { }
   # Dentro das chaves você poem o script.
   # * Exemplo :
   #   Dax.required_class("Window_Base") {
   #     class Window_Base < Window
   #        def example
   #          self.x = self.x + self.width
   #        end
   #     end
   #   }
   #----------------------------------------------------------------------------
   # Executa o bloco se o objeto existir.
   #----------------------------------------------------------------------------
   def required_class(name, &block)
     return unless defined?(name)
     eval("block.call if defined?(name)")
   end
   #----------------------------------------------------------------------------
   # • Fazer benchmark de um bloco. O resultado será impresso no Console do
   # Maker.
   #----------------------------------------------------------------------------
   # Dax.benchmark(name(opcional)) { BLOCO }
   #----------------------------------------------------------------------------
   def benchmark(name="", &block)
     time = Time.now
     block.call
     print "Benchmark: #{(time - Time.now).abs.to_f} segundos!\r\n"
     @benchmark += "#{name} : #{(time - Time.now).to_f} segundos!\r\n"
   end
   #----------------------------------------------------------------------------
   # • Salva os testes de benchmark num arquivo chamado 'Benchmark' de extensão
   # .txt.
   #----------------------------------------------------------------------------
   def benchmark_save
     self.required_file("Benchmark.txt") { File.delete("Benchmark.txt") }
     File.open("Benchmark.txt", "a+") do |file|
       file.write(@benchmark)
       file.close
     end
   end
   #----------------------------------------------------------------------------
   # • Requirir um arquivo.
   #     arquivo : Arquivo...
   #----------------------------------------------------------------------------
   def require(arquivo)
     $: << "./"
     Kernel.send(:require, arquivo)
   end
   #----------------------------------------------------------------------------
   # * Somente executa um bloco case existir um arquivo.
   #----------------------------------------------------------------------------
   # Dax.required_file("arquivo.tipo") { # Exemplo.
   #  Métodos;
   # }
   #----------------------------------------------------------------------------
   def required_file(filename, &block)
     return unless FileTest.exist?(filename)
     block.call
   end
   # Requer a existência de uma pasta para executar tal bloco.
   def required_directory(directory, &block)
     return unless File.directory?(directory) and block_given?
     block.call
   end
-  def required_past(directory, &block)
+
   # * Remove uma [Classe], exemplo: Dax.remove(:Scene_Menu)
   #----------------------------------------------------------------------------
   def remove(symbol_name)
     Object.send(:remove_const, symbol_name)
   end
   #----------------------------------------------------------------------------
   # * Retorna a variável [$RGSS_SCRIPT]
   #----------------------------------------------------------------------------
   def rgss_script
     return $RGSS_SCRIPTS
   end
   #----------------------------------------------------------------------------
   # * Tela chéia
   #----------------------------------------------------------------------------
   def full_screen
     res = Win32API.new 'user32', 'keybd_event', %w(l l l l), ''
     res.call(18,0,0,0)
     res.call(13,0,0,0)
     res.call(13,0,2,0)
     res.call(18,0,2,0)
   end
 end
 #==============================================================================
 # • Module
 #==============================================================================
 Dax.register(:module)
 class Module
   #----------------------------------------------------------------------------
   # • Declarar uma variável com o valor.;
   #----------------------------------------------------------------------------
   def attr_value(symbol, value=nil)
     attr_accessor(symbol)
-  # • Definir um atributo com um valor. O atributo pode ser modificado e lido.
+    module_eval("def #{symbol}
-  # attr_value :symbol, value
+     @#{symbol} = #{value} unless defined?(@#{symbol})
      return @#{symbol}
     end")
     return nil
-    module_eval ("
+
-     def #{symbol}
+
-       @#{symbol} = #{value} unless defined?(@#{symbol})
+
-       return @#{symbol}
+
-     end
+
-    ")
+
 Dax.register(:api)
 module API
   extend self
   # CopyFile
   CopyFile = Win32API.new('kernel32', 'CopyFile', 'ppl', 'l')
   # Beep
   Beep = Win32API.new('kernel32', 'Beep', 'LL', 'L')
   # KeybdEvent
   KEYBD_EVENT         = Win32API.new('user32', 'keybd_event', 'LLLL', '')
   # Permite acessar as teclas do teclado.
   GetKeyState    = Win32API.new('user32', 'GetAsyncKeyState', 'i', 'i')
   # Permite ativar/desativar o ícone do mouse.
   MouseShowCursor = Win32API.new("user32", "ShowCursor", "i", "i")
   # Permite achar a posição do mouse.
   CursorPosition = Win32API.new('user32', 'GetCursorPos', 'p', 'i')
   # Permite achar o tamanho da screen.
   ScreenToClient = Win32API.new('user32', 'ScreenToClient', %w(l p), 'i')
   # Permite fazer a leitura do game.ini.
   ReadIni = Win32API.new('kernel32', 'GetPrivateProfileStringA', %w(p p p p l p), 'l')
   # Permite achar o tamando da window.
   FindWindow = Win32API.new('user32', 'FindWindowA', %w(p p), 'l')
   # API da Message Box.
   MessageBoxA = Win32API.new('user32', 'MessageBoxA', %w(p p p i), 'i')
   # Recupera uma string especificada de um arquivo em inicialização.
   GetPrivateProfileString = Win32API.new('kernel32', 'GetPrivateProfileStringA',%w(p p p p l p),'l')
   # Get Systeme Metrics
   GetSystemMetrics = Win32API.new("user32", "GetSystemMetrics", "i", "i")
   # Posição da janela.
   SetWindowPos = Win32API.new("user32", "SetWindowPos", "lliiiii", "i")
   # Obtem o 'Rect' da janela.
   GetWindowRect = Win32API.new('user32','GetWindowRect',%w(l p),'i')
   # Define a Win32API do comando print
   MessageBoxW = Win32API.new("user32", "MessageBoxW", "LPPL", "L")
   #----------------------------------------------------------------------------
   # • Obter Caps Lock
   #----------------------------------------------------------------------------
   def get_caps_lock
     if Win32API.new("user32", "GetKeyState", "i", "i").call(20) == 1
       return true
     else
       return false
     end
   end
   # State Key
   StateKey = Win32API.new("user32", "GetKeyState", ["i"], "i")
   # SetCursorPos
   SetCursorPos    = Win32API.new("user32", "SetCursorPos", "ll", "i")
   SetCursorPos    = Win32API.new("user32", "SetCursorPos", "ii", "i")
   GetKeyboardState = Win32API.new('user32', 'GetKeyboardState', ['P'], 'V')
   GetAsyncKeyState = Win32API.new('user32', 'GetAsyncKeyState', 'i', 'i')
   # Criar uma nova pasta.
   CreateDirectory = Win32API.new("kernel32", "CreateDirectory", "p", "lll")
   # Remover uma pasta existente.
   RemoveDirectory = Win32API.new("kernel32", "RemoveDirectory", "p", "l")
   WideCharToMultiByte = Win32API.new('kernel32', 'WideCharToMultiByte', 'ilpipipp', 'i')
   MultiByteToWideChar = Win32API.new('kernel32', 'MultiByteToWideChar', 'ilpipi', 'i')
   # ZeroMemory
   ZeroMemory = Win32API.new("kernel32", "RtlZeroMemory", "pl", "")
   # retorna para a data do ponteiro.
   def copymen(len)
     buf = "\0" * len
     Win32API.new("kernel32", "RtlMoveMemory", "ppl", "").call(buf, self, len)
     buf
   end
   # Shell
   Open = Win32API.new('shell32', 'ShellExecute', 'LPPPPI', 'L')
   def open_file(name)
     API::Open.call(0, 'open', "#{name}.exe", 0, 0, 1)
   end
   # Abrir site
   def open_site(url)
      c = Win32API.new("Shell32", "ShellExecute", "pppppl", "l")
     c.call(nil, "open", url, nil, nil, 0)
   end
   # Converter o formado do texto.
   def convert_text(text, from, to)
     size = MultiByteToWideChar.(from, 0, text, -1, nil, 0)
     buffer = [].pack("x#{size*2}")
 
     MultiByteToWideChar.(from, 0, text, -1, buffer, buffer.size/2)
     size = WideCharToMultiByte.(to, 0, buffer, -1, nil, 0, nil, nil)
     second_buffer = [].pack("x#{size}")
     WideCharToMultiByte.(to, 0, buffer, -1, second_buffer, second_buffer.size, nil, nil)
     second_buffer.delete!("\000") if to == 65001
     second_buffer.delete!("\x00") if to == 0
     return second_buffer
   end
   #----------------------------------------------------------------------------
   # • Constantes do módulo.
   #----------------------------------------------------------------------------
   VK_SNAPSHOT = 44.0
   KEYEVENTF_EXTENDEDKEY = 0xE0
   KEYEVENTF_KEYUP = 0x0002
   CF_BITMAP = 2
   # keybd_event(*arguments)
   def keybd_event(*args)
     KEYBD_EVENT.call(*args)
   end
   # openClipboard
   def openClipboard(*args)
     OpenClipboard.call(*args)
   end
   # ZeroMemory
   def zeroMemory(*args)
     ZeroMemory.call(*args)
   end
   # Copiar arquivo
   def copyFile(*args)
     CopyFile.call(*args)
   end
 end
 #==============================================================================
 # • Clipboard
 #==============================================================================
 Dax.register :clipboard
 module Clipboard
   extend self
   #----------------------------------------------------------------------------
   # • Constantes do módulo:
   #----------------------------------------------------------------------------
   Close = Win32API.new("user32", "CloseClipboard", "v", "l")
   GetData = Win32API.new("user32", "GetClipboardData", "n", "l")
   Open = Win32API.new('user32', 'OpenClipboard', "N", "L")
   FormatAvailable = Win32API.new('user32', 'IsClipboardFormatAvailable', "i", "i")
   GlobalAlloc = Win32API.new('kernel32', 'GlobalAlloc', 'll', 'l')
   GlobalLock = Win32API.new('kernel32', 'GlobalLock', 'l', 'l')
   GlobalSize = Win32API.new('kernel32', 'GlobalSize', 'l', 'l')
   GlobalUnlock = Win32API.new('kernel32', 'GlobalUnlock', 'l', '')
   MemCpy = Win32API.new('ntdll', 'memcpy', 'ppl', 'l')
   FORMATS = {text: 1, dib: 2, bitmap: 8}
   #----------------------------------------------------------------------------
   # • Data. Retorna a Data do clipboard. Especificar o formato para receber
   # o retorno do formato especifico. Formato padrão é o texto.
   #----------------------------------------------------------------------------
   def data(format=FORMATS[:text])
     begin
       self.open
         if FormatAvailable.call(format)
           handle = GetData.call(format)
           case format
           when 1
             clip_data = 0.chr * GlobalSize.call(handle)
             MemCpy.call(clip_data, handle, clip_data.size)
             clip_data = clip_data[ /^[^\0]*/ ]
           when 2, 8 then clip_data = get_image_data(handle)
           else
             raise Error, 'format not supported'
           end
         else
           clip_data = ''
         end
       ensure
         self.close
       end
     clip_data
   end
   #----------------------------------------------------------------------------
   # • Singleton Class
   #----------------------------------------------------------------------------
   class << self
     alias :get_data :data
   end
   #----------------------------------------------------------------------------
   # • Formato aceito.
   #----------------------------------------------------------------------------
   def formatAvailable?(format)
     FormatAvailable.call(format).boolean
   end
   private
   #----------------------------------------------------------------------------
   # • Abrir clipboard
   #----------------------------------------------------------------------------
   def open
     Open.call(0)
   end
   #----------------------------------------------------------------------------
   # • Fechar
   #----------------------------------------------------------------------------
   def close
     Close.call
   end
   #----------------------------------------------------------------------------
   # • Obter a data de uma imagem, bitmap.
   #----------------------------------------------------------------------------
   def get_image_data(handle)
     buf = nil
     bmi = 0.chr * 44 # BITMAPINFO
     begin
       address  = GlobalLock.call(handle)
       buf_size = GlobalSize.call(handle)
       MemCpy.call(bmi, address, bmi.length)
       bit_count   = bmi[14,2].unpack('S').first # biBitCount
       compression = bmi[16,4].unpack('L').first # biCompression
       size_image  = bmi[20,4].unpack('L').first # biSizeImage
       clr_used    = bmi[32,4].unpack('L').first # biClrUsed
       size_image = buf_size + 16 if size_image == 0
       # Calculate the header size
       case bit_count
       when 1 then table_size = 2
       when 4 then table_size = 16
       when 8 then table_size = 256
       when 16, 32
         if compression == 0
           table_size = clr_used
         elsif compression == 3
           table_size = 3
         else
           msgbox "ERROR: invalid bit/compression combination"
         end
       when 24 then table_size = crl_used
       else
         msgbox "ERROR: invalid bit count"
       end
       offset = 0x36 + (table_size * 4)
       buf = 0.chr * buf_size
       MemCpy.call(buf, address, buf.size)
       buf = "\x42\x4D" + [size_image].pack('L') + 0.chr * 4 + [offset].pack('L') + buf
     ensure
       GlobalUnlock.call(handle)
     end
     buf
   end
 end
 #==============================================================================
 # • Enumerables;
 #==============================================================================
 Dax.register(:enumerables)
 module Enumerables
   #----------------------------------------------------------------------------
   # • Retorna a uma nova array com todos os resultados retirando os zeros.
   #----------------------------------------------------------------------------
   def select_map(&aProc)
     map(&aProc).reject { |e| e.nil? }
   end
 end
 #==============================================================================
 # * String
 #==============================================================================
 Dax.register(:string)
 class String
   #----------------------------------------------------------------------------
   # * Obtem a palavra do méio de uma frase/palavra
   #----------------------------------------------------------------------------
   def get_string_between(start_at, end_at)
     my_string = " #{self}"
     ini = my_string.index(start_at)
     return my_string if ini == 0
     ini += start_at.length
     length = my_string.index(end_at, ini).to_i - ini
     return my_string[ini,length]
   end
   #--------------------------------------------------------------------------
   # * retorna self em ASCII-8BIT
   #--------------------------------------------------------------------------
   def to_ascii
     API.convert_text(self, 65001, 0)
   end
   #--------------------------------------------------------------------------
   # * converte self em ASCII-8BIT
   #--------------------------------------------------------------------------
   def to_ascii!
     self.replace(self.to_ascii)
   end
   #--------------------------------------------------------------------------
   # * retorna self para UTF8
   #--------------------------------------------------------------------------
   def to_utf8
     API.convert_text(self, 0, 65001)
   end
   #--------------------------------------------------------------------------
   # * converte self em UTF8
   #--------------------------------------------------------------------------
   def to_utf8!
     self.replace(self.to_utf8)
   end
   #--------------------------------------------------------------------------
   # * Extrai os números.
   #--------------------------------------------------------------------------
   def extract_numbers
     self.scan(/-*\d+/).collect{|n|n.to_i}
   end
   #----------------------------------------------------------------------------
   # • Aplicando Case Sensitive
   #   "Exemplo 2" => "Exemplo_2"
   #----------------------------------------------------------------------------
   def case_sensitive
     return self.gsub(" ", "_")
   end
   #----------------------------------------------------------------------------
   # • Transormar em símbolo.
   #----------------------------------------------------------------------------
   def symbol
     return self.case_sensitive.downcase.to_sym
   end
 end
 #==============================================================================
 # • DString
 #==============================================================================
 Dax.register :dstring
 module DString
   extend self
   #----------------------------------------------------------------------------
   # • Deletar a útlima letra de uma string..
   # Exemplo: DString.backslash("ok!") #=> ok
   #----------------------------------------------------------------------------
   def backslash(text)
     text2 = ""
     text = text.to_s.split(//)
     text[text.size-1] = "" unless text[0].to_s.empty?
     for i in 0..text.size-1
       text2 += text[i].to_s
     end
     return text2
   end
 end
 #==============================================================================
 # * Integer
 #==============================================================================
 Dax.register(:integer)
 class Integer
   #----------------------------------------------------------------------------
   # • Verifica se e par.
   #----------------------------------------------------------------------------
   def is_evan?
     return (self & 1) == 0
   end
   #----------------------------------------------------------------------------
   # • Verifica se e impar.
   #----------------------------------------------------------------------------
   def is_odd?
-  def par?
+
   end
   #----------------------------------------------------------------------------
   # * Transformar o valor em porcentagem : Útil para fazer barras como por exemplo
   # barras de HP.
   #    a : Valor atual.
-  def impar?
+
   #    b : Valor máximo.
   #----------------------------------------------------------------------------
   def to_p(a, b)
     self * a / b
   end
   #----------------------------------------------------------------------------
   # * Grid On : Multiplica o número pelo tamanho de uma grid.
   #----------------------------------------------------------------------------
   def grid_on(grid_size=32)
     return self * grid_size
   end
   #----------------------------------------------------------------------------
   # * Grid Off : Divide o número pelo tamanho de uma grid.
   #----------------------------------------------------------------------------
   def grid_off(grid_size=32)
     return self / grid_size
   end
   #----------------------------------------------------------------------------
   # • Divisores primos
   #----------------------------------------------------------------------------
   def primeDivision
     raise ZeroDivisionError if self == 0
     ps = DMath::Prime.new
     value = self
     pv = []
     for prime in ps
       count = 0
       while (value1, mod = value.divmod(prime)
         mod) == 0
         value = value1
         count += 1
       end
       pv.push [prime, count] unless count == 0
       break if prime * prime  >= value
     end
     pv.push [value, 1] if value > 1
     return pv
   end
 end
 #==============================================================================
 # * Float
 #==============================================================================
 Dax.register(:float)
 class Float
   #----------------------------------------------------------------------------
   # * Transformar em porcentagem :
   #    a : Valor atual.
   #    b : Valor máximo.
   #----------------------------------------------------------------------------
   def to_p(a, b)
     self * a / b
   end
 end
 #==============================================================================
 # • Crypt
 #==============================================================================
 Dax.register(:crypt)
 module Crypt
   module Cesar # Criptografia de Cesar
     extend self
     AZ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(//)
     DC = "DEFGHIJKLMNOPQRSTUVWXYZABC".split(//)
     def codify(string, ty=0)
       string = string.split(//)
       ns = ""
       dc = []
       string.each { |i|
        next dc << "" if i == ""
        next dc << " " if i == " "
        AZ.each_with_index { |v, id|
         next dc << DC[id] if i == v
        }}
        dc.size.times { |i| ns += dc[i] }
        return ty == 0 ? ns : ns.downcase!
     end
 
     def decodify(string, ty=0)
       string = string.split(//)
       ns = ""
       az = []
       string.each { |i|
        next az << "" if i == ""
        next az << " " if i == " "
        DC.each_with_index { |v,id|
         next az << AZ[id] if i == v
        }
       }
       az.size.times { |i| ns += az[i] }
       return ty == 0 ? ns : ns.downcase!
     end
 
   end
 end
 #==============================================================================
 # * Color
 #==============================================================================
 Dax.register(:color)
 class Color
   #----------------------------------------------------------------------------
   # • Diminui a opacidade da cor, deixando-a opaca..
   #----------------------------------------------------------------------------
   def opacity(alpha=nil)
     self.set(self.red, self.green, self.blue, alpha || 128)
   end
   #----------------------------------------------------------------------------
   # • Inverte as cores.
   #----------------------------------------------------------------------------
   def invert!
     self.set(255-self.red, 255-self.green, 255-self.blue, self.alpha)
   end
   #----------------------------------------------------------------------------
   # • Reverter as cores.
   #----------------------------------------------------------------------------
   def revert
     colors = [self.red, self.green, self.blue, self.alpha].reverse!
     self.set(*colors)
   end
   #----------------------------------------------------------------------------
   # • Converte para string.
   #----------------------------------------------------------------------------
   def to_s
     "red: #{self.red}\nblue: #{self.blue}\ngreen: #{self.green}\nalpha: #{self.alpha}"
   end
   #----------------------------------------------------------------------------
   # • Comparar cores, retorna a [true] se for igual.. returna a [false] se não
   # for igual.
   #----------------------------------------------------------------------------
   def ==(color)
     (self.red == color.red and self.green == color.green and self.blue == color.blue and
       self.alpha == color.alpha) ? true : false
   end
   #----------------------------------------------------------------------------
   # • Retorna os valores da classe [COLOR] para hash;;
   #----------------------------------------------------------------------------
   def to_h
     return {
       red: self.red, green: self.green, blue: self.blue, alpha: self.alpha,
     }
   end
   #----------------------------------------------------------------------------
   # • Retorna os valores da classe [COLOR] para array;;
   #----------------------------------------------------------------------------
   def to_a
     return [self.red, self.green, self.blue, self.alpha]
   end
   #----------------------------------------------------------------------------
   # • Soma os valores das cores com os valores de outras cores.
   # Ex: color + Color.new(21,54,255)
   #----------------------------------------------------------------------------
   def +(color)
     return unless color.is_a?(Color)
     red = self.red + color.red
     green = self.green + color.green
     blue = self.blue + color.blue
     self.set(red, green, blue)
   end
   #----------------------------------------------------------------------------
   # • Subtrai os valores das cores com os valores de outras cores.
   # Ex: color - Color.new(21,54,255)
   #----------------------------------------------------------------------------
   def -(color)
     return unless color.is_a?(Color)
     red = self.red - color.red
     green = self.green - color.green
     blue = self.blue - color.blue
     self.set(red, green, blue)
   end
   #----------------------------------------------------------------------------
   # • Multiplica os valores das cores com os valores de outras cores.
   # Ex: color * Color.new(21,54,255)
   #----------------------------------------------------------------------------
   def *(color)
     return unless color.is_a?(Color)
     red = (self.red * color.red) / 255.0
     green = (self.green * color.green) / 255.0
     blue = (self.blue * color.blue) / 255.0
     self.set(red, green, blue)
   end
 end
 #==============================================================================
 # * ColorBasic
 #==============================================================================
 Dax.register(:colorbasic)
 module ColorBasic
   extend self
   #----------------------------------------------------------------------------
   # • Cores Hexadécimais
   #    * ColorBasic.hex("ffffff") #=> 255, 255, 255 | Branco.
   #----------------------------------------------------------------------------
   def hex(color)
     Color.new(*color.scan(/../).map { |color| color.to_i(16)})
   end
   #----------------------------------------------------------------------------
   # • Cores em Index
   #----------------------------------------------------------------------------
   def [](id)
     case id
     when -1 then Color.new(255, 255, 255) # White
     when 0 then Color.new(240, 248, 255) # Alice Blue
     when 1 then Color.new(250, 235, 215) # Antique_White
     when 2 then Color.new(0, 255, 255) # Aqua
     when 3 then Color.new(127, 255, 255) # Aqua Marine
     when 4 then Color.new(240, 255, 255) # Azure
     when 5 then Color.new(245, 245, 220) # Beige
     when 6 then Color.new(255, 228, 196) # Bisque
     when 7 then Color.new(0, 0, 0) # Black
     when 8 then Color.new(255, 235, 205) # Blanchedalmond
     when 9 then Color.new(0, 0, 255) # Blue
     when 10 then Color.new(138, 43, 226) # Blue Violet
     when 11 then Color.new(165, 42, 42) # Brown
     when 12 then Color.new(222, 184, 135) # Burly Wood
     when 13 then Color.new(93, 158, 160) # Cadet Blue
     when 14 then Color.new(127, 255, 0) # Chatreuse
     when 15 then Color.new(210, 105, 30) # Chocolate
     when 16 then Color.new(255, 127, 80) # Coral
     when 17 then Color.new(100, 149, 237) # Corn Flower Blue
     when 18 then Color.new(255, 248, 220) # CornSilk
     when 19 then Color.new(220, 20, 60) # Crimson
     when 20 then Color.new(0, 255, 255) # Cyan
     when 21 then Color.new(0, 0, 139) # DarkBlue
     when 22 then Color.new(0, 139, 139) # DarkCyan
     when 23 then Color.new(184, 134, 11) # DarkGoldEnrod
     when 24 then Color.new(169, 169, 169) # Dark Gray
     when 25 then Color.new(0, 100, 0) # Dark Green
     when 26 then Color.new(189, 183, 107) # Dark Khaki
     when 27 then Color.new(139, 0, 139) # Dark Magenta
     when 28 then Color.new(85, 107, 47) # Dark Oliver Green
     when 29 then Color.new(255, 140, 0) # Dark Orange
     when 30 then Color.new(153, 50, 204) # Dark orchid
     when 31 then Color.new(139, 0, 0) # Dark Red
     when 32 then Color.new(233, 150, 120) # Dark Salmon
     when 33 then Color.new(143, 188, 143) # Dark Sea Green
     when 34 then Color.new(72, 61, 139) # Dark Slate Blue
     when 35 then Color.new(255, 255, 0) # Yellow
     when 36 then Color.new(255, 0, 0) # Red
     when 37 then Color.new(0, 255, 0) # Green
     when 38 then Color.new(255, 128, 0) # Orange
     else
       self.default
     end
   end
   #----------------------------------------------------------------------------
   # • Cor padrão.
   #----------------------------------------------------------------------------
   def default
     return self.hex "ffffff"
   end
   #----------------------------------------------------------------------------
   # • * Forma uma cor aleátoria, retornando para um objeto de Cor.
   #----------------------------------------------------------------------------
   def rand
     return Color.new(rand(256), rand(256), rand(256))
   end
 end
 #==============================================================================
 # • Rect
 #==============================================================================
 Dax.register(:rect)
 class Rect
   #----------------------------------------------------------------------------
   # • Verificar se está na área.
   #----------------------------------------------------------------------------
   def in?(x, y)
     x.between?(self.x, self.x + self.width) &&
     y.between?(self.y, self.y + self.height)
   end
 end
 #==============================================================================
 # • DMath
 #==============================================================================
 Dax.register(:dmath, 'Dax', 1.5, '04/05/13')
 module DMath
   extend self
   #----------------------------------------------------------------------------
   # • Clamp | Delimitar o inteiro
   #    num : Número.
   #    low : Número minímo. Sê o 'num' for menor que min retorna a low.
   #    high : Número máximo. Sê o 'num' for maior que hight retorna a high.
   #----------------------------------------------------------------------------
   def clamp(num, low, high)
     return num < low ? low : num > high ? high : low
   end
   #----------------------------------------------------------------------------
   # • Centralizar um objeto n'outro.
   #    object : Objeto, tem que ser do tipo [Sprite] ou [Window_Base]
   #    object_for_centralize : Objeto que irá se centralizar no 'object', tem
   # que ser do tipo [Sprite] ou [Window_Base]
   # * Retorna a uma Array contendo as informações das novas posições em X e Y.
   #----------------------------------------------------------------------------
   def centralize_object(object, object_for_centralize)
     x = object.x + (object.width - object_for_centralize.width) / 2
     y = object.y + (object.height - object_for_centralize.height) / 2
     return x, y
   end
   #----------------------------------------------------------------------------
   # • Centralizar um objeto n'outro, obtendo somente a posição X.
   #    objectx : Valor da posição X do objeto número 1.
   #    objectwidth : Valor da largura do objeto número 1.
   #    object_for_centralizewidth : Valor da largura do objeto que irá se
   # centralizar no objeto número 1.
   # * Retorna ao valor da posição X.
   #----------------------------------------------------------------------------
   def centralize_x(objectx, objectwidth, object_for_centralizewidth)
     return objectx + (objectwidth - object_for_centralizewidth) / 2
   end
   #----------------------------------------------------------------------------
   # • Centralizar um objeto n'outro, obtendo somente a posição Y.
   #    objecty : Valor da posição Y do objeto número 1.
   #    objectheight : Valor da altura do objeto número 1.
   #    object_for_centralizeheight : Valor da altura do objeto que irá se
   # centralizar no objeto número 1.
   # * Retorna ao valor da posição Y.
   #----------------------------------------------------------------------------
   def centralize_y(objecty, objectheight, object_for_centralizeheight)
     return objecty + (objectheight - object_for_centralizeheight) / 2
   end
   #----------------------------------------------------------------------------
   # • **** Método ainda não explicado ********
   #----------------------------------------------------------------------------
   def rotc(vmn, v, vmx, c = 100)
     ((v - vmn) * c) / (vmx - vmn)
   end
   #----------------------------------------------------------------------------
   # • Obter a posição X do centro da tela referente a largura do objeto X.
   # Exemplo: get_x_center_screen(sprite.width) : Irá retornar ao valor da posição
   # X para que o objeto fique no centro da tela.
   # Exemplo: sprite.x = get_x_center_screen(sprite.width)
   #----------------------------------------------------------------------------
   def get_x_center_screen(width)
     return (Graphics.width - width) / 2
   end
   #----------------------------------------------------------------------------
   # • Obter a posição Y do centro da tela referente a altura do objeto X.
   # Exemplo: get_y_center_screen(sprite.height) : Irá retornar ao valor da posição
   # Y para que o objeto fique no centro da tela.
   # Exemplo: sprite.y = get_y_center_screen(sprite.height)
   #----------------------------------------------------------------------------
   def get_y_center_screen(height)
     return (Graphics.height - height) / 2
   end
   #--------------------------------------------------------------------------
   # • Verifica se um objeto está na área de um círculo.
   #    object : Objeto do tipo da classe [Sprite].
   #    object2 : Objeto do tipo da classe [Sprite].
   #    size : Tamanho geral do círculo.
   #--------------------------------------------------------------------------
   def circle(object, object2, size)
     ( (object.x - object2.x) ** 2) + ( (object.y - object2.y) ** 2) <= (size ** 2)
   end
   #----------------------------------------------------------------------------
   # • Converter o valor em graus.
   #----------------------------------------------------------------------------
   def graus
     360 / (2 * Math::PI)
   end
   #----------------------------------------------------------------------------
   # • ********* Método ainda não explicado ******
   #----------------------------------------------------------------------------
   def radian(degree)
     return (degree.to_f/180) * Math::PI
   end
   #----------------------------------------------------------------------------
   # • ********* Método ainda não explicado ******
   #----------------------------------------------------------------------------
   def degree(radian)
     return (radian.to_f/Math::PI) * 180
   end
   #----------------------------------------------------------------------------
   # • Para 4 decimals.
   #----------------------------------------------------------------------------
   def to_4_dec(n)
     ((n * 1000).ceil) / 1000
   end
   #----------------------------------------------------------------------------
   # • Área de um triângulo.
   #----------------------------------------------------------------------------
   def triangle_area(*args)
     x, y, x2, y2, x3, y3 = *args
     return (x2 - x) * (y3 - y) - (x3 - x) * (y2 - y)
   end
   #----------------------------------------------------------------------------
   # • Calcular distância para scripts como sensor.
   #----------------------------------------------------------------------------
   def distance_sensor(target, target2)
     return (target.x - target2.x).abs + (target.y - target2.y).abs
   end
   #============================================================================
   # • Prime
   #============================================================================
   class Prime
     #--------------------------------------------------------------------------
     # • Variáveis públicas
     #--------------------------------------------------------------------------
     attr_accessor :primes, :counts
     #--------------------------------------------------------------------------
     # • Incluir
     #--------------------------------------------------------------------------
     include Enumerables
     #--------------------------------------------------------------------------
     # • Inicialização dos objetos.
     #--------------------------------------------------------------------------
     def initialize
       @seed ||= 1
       @primes ||= []
       @counts ||= []
     end
     #--------------------------------------------------------------------------
     # • Succ
     #--------------------------------------------------------------------------
     def succ
       i = -1
       size = @primes.size
       while i < size
         if i == -1
           @seed += 1
           i += 1
         else
           while @seed > @counts[i]
             @counts[i] += @primes[i]
           end
           i = @seed != @counts[i] ? i + 1 : -1
         end
       end
       @primes.push @seed
       @counts.push @seed + @seed
       return @seed
     end
     alias next succ
     #--------------------------------------------------------------------------
     # • Cada elemento
     #--------------------------------------------------------------------------
     def each
       loop { yield succ }
     end
   end
   #----------------------------------------------------------------------------
   # • Dentro do círculo.
   #----------------------------------------------------------------------------
   def circle_in(t, b, c, d)
     return -c * (Math.sqrt(1 - (t /= d.to_f) * t) - 1) + b
   end
   #----------------------------------------------------------------------------
   # • Fora do círculo
   #----------------------------------------------------------------------------
   def circle_out(t, b, c, d)
     return c * Math.sqrt(1 - (t=t/d.to_f-1)*t) + b
   end
 end
 #==============================================================================
 # • Keyboard | Método para usar todas as teclas do teclado.
 #==============================================================================
 Dax.register(:key, "Dax", 1.0)
 module Key
   extend self
   #--------------------------------------------------------------------------
   # * Chaves diversos.
   #--------------------------------------------------------------------------
   CANCEL              = 0x03 # Control-Break Processing
   BACKSPACE           = 0x08 # Backspace Key
   TAB                 = 0x09 # Tab Key
   CLEAR               = 0x0C # Clear Key
   ENTER               = 0x0D # Enter Key
   SHIFT               = 0x10 # Shift Key
   CONTROL             = 0x11 # Ctrl Key
   MENU                = 0x12 # Alt Key
   PAUSE               = 0x13 # Pause Key
   ESC                 = 0x1B # Esc Key
   CONVERT             = 0x1C # IME Convert Key
   NONCONVERT          = 0x1D # IME Nonconvert Key
   ACCEPT              = 0x1E # IME Accept Key
   SPACE               = 0x20 # Space Bar Key (Space, usually blank)
   PRIOR               = 0x21 # Page Up Key
   NEXT                = 0x22 # Page Down Key
   ENDS                = 0x23 # End Key
   HOME                = 0x24 # Home Key
   LEFT                = 0x25 # Left Arrow Key
   UP                  = 0x26 # Up Arrow Key
   RIGHT               = 0x27 # Right Arrow Key
   DOWN                = 0x28 # Down Arrow Key
   SELECT              = 0x29 # Select Key
   PRINT               = 0x2A # Print Key
   EXECUTE             = 0x2B # Execute Key
   SNAPSHOT            = 0x2C # Print Screen Key
   DELETE              = 0x2E # Delete Key
   HELP                = 0x2F # Help Key
   LSHIFT              = 0xA0 # Left Shift Key
   RSHIFT              = 0xA1 # Right Shift Key
   LCONTROL            = 0xA2 # Left Control Key (Ctrl)
   RCONTROL            = 0xA3 # Right Control Key (Ctrl)
   LMENU               = 0xA4 # Left Menu Key (Alt)
   RMENU               = 0xA5 # Right Menu Key (Alt)
   PACKET              = 0xE7 # Used to Pass Unicode Characters as Keystrokes
   MOUSE_RIGHT         = 0x01 # Button Mouse Right
   MOUSE_LEFT          = 0x02 # Button Mouse Left
   MOUSE_MIDDLE        = 0x04 # Button Mouse Middle
   #--------------------------------------------------------------------------
   # * Chaves de números.
   #--------------------------------------------------------------------------
   N0                  = 0x30 # 0 Key
   N1                  = 0x31 # 1 Key
   N2                  = 0x32 # 2 Key
   N3                  = 0x33 # 3 Key
   N4                  = 0x34 # 4 Key
   N5                  = 0x35 # 5 Key
   N6                  = 0x36 # 6 Key
   N7                  = 0x37 # 7 Key
   N8                  = 0x38 # 8 Key
   N9                  = 0x39 # 9 Key
   #--------------------------------------------------------------------------
   # * Chaves de letras
   #--------------------------------------------------------------------------
   A                   = 0x41 # A Key
   B                   = 0x42 # B Key
   C                   = 0x43 # C Key
   D                   = 0x44 # D Key
   E                   = 0x45 # E Key
   F                   = 0x46 # F Key
   G                   = 0x47 # G Key
   H                   = 0x48 # H Key
   I                   = 0x49 # I Key
   J                   = 0x4A # J Key
   K                   = 0x4B # K Key
   L                   = 0x4C # L Key
   M                   = 0x4D # M Key
   N                   = 0x4E # N Key
   O                   = 0x4F # O Key
   P                   = 0x50 # P Key
   Q                   = 0x51 # Q Key
   R                   = 0x52 # R Key
   S                   = 0x53 # S Key
   T                   = 0x54 # T Key
   U                   = 0x55 # U Key
   V                   = 0x56 # V Key
   W                   = 0x57 # W Key
   X                   = 0x58 # X Key
   Y                   = 0x59 # Y Key
   Z                   = 0x5A # Z Key
   #--------------------------------------------------------------------------
   # * Chaves de windows
   #--------------------------------------------------------------------------
   LWIN                = 0x5B # Left Windows Key (Natural keyboard)
   RWIN                = 0x5C # Right Windows Key (Natural Keyboard)
   APPS                = 0x5D # Applications Key (Natural keyboard)
   SLEEP               = 0x5F # Computer Sleep Key
   BROWSER_BACK        = 0xA6 # Browser Back Key
   BROWSER_FORWARD     = 0xA7 # Browser Forward Key
   BROWSER_REFRESH     = 0xA8 # Browser Refresh Key
   BROWSER_STOP        = 0xA9 # Browser Stop Key
   BROWSER_SEARCH      = 0xAA # Browser Search Key
   BROWSER_FAVORITES   = 0xAB # Browser Favorites Key
   BROWSER_HOME        = 0xAC # Browser Start and Home Key
   VOLUME_MUTE         = 0xAD # Volume Mute Key
   VOLUME_DOWN         = 0xAE # Volume Down Key
   VOLUME_UP           = 0xAF # Volume Up Key
   MEDIA_NEXT_TRACK    = 0xB0 # Next Track Key
   MEDIA_PREV_TRACK    = 0xB1 # Previous Track Key
   MEDIA_STOP          = 0xB2 # Stop Media Key
   MEDIA_PLAY_PAUSE    = 0xB3 # Play/Pause Media Key
   LAUNCH_MAIL         = 0xB4 # Start Mail Key
   LAUNCH_MEDIA_SELECT = 0xB5 # Select Media Key
   LAUNCH_APP1         = 0xB6 # Start Application 1 Key
   LAUNCH_APP2         = 0xB7 # Start Application 2 Key
   PROCESSKEY          = 0xE5 # IME Process Key
   ATTN                = 0xF6 # Attn Key
   CRSEL               = 0xF7 # CrSel Key
   EXSEL               = 0xF8 # ExSel Key
   EREOF               = 0xF9 # Erase EOF Key
   PLAY                = 0xFA # Play Key
   ZOOM                = 0xFB # Zoom Key
   PA1                 = 0xFD # PA1 Key
   #--------------------------------------------------------------------------
   # * Chaves do Numpad
   #--------------------------------------------------------------------------
   NUMPAD0             = 0x60 # Numeric Keypad 0 Key
   NUMPAD1             = 0x61 # Numeric Keypad 1 Key
   NUMPAD2             = 0x62 # Numeric Keypad 2 Key
   NUMPAD3             = 0x63 # Numeric Keypad 3 Key
   NUMPAD4             = 0x64 # Numeric Keypad 4 Key
   NUMPAD5             = 0x65 # Numeric Keypad 5 Key
   NUMPAD6             = 0x66 # Numeric Keypad 6 Key
   NUMPAD7             = 0x67 # Numeric Keypad 7 Key
   NUMPAD8             = 0x68 # Numeric Keypad 8 Key
   NUMPAD9             = 0x69 # Numeric Keypad 9 Key
   MULTIPLY            = 0x6A # Multiply Key (*)
   ADD                 = 0x6B # Add Key (+)
   SEPARATOR           = 0x6C # Separator Key
   SUBTRACT            = 0x6D # Subtract Key (-)
   DECIMAL             = 0x6E # Decimal Key (.)
   DIVIDE              = 0x6F # Divide Key (/)
   #--------------------------------------------------------------------------
   # * Chaves de funções
   #--------------------------------------------------------------------------
   F1                  = 0x70 # F1 Key
   F2                  = 0x71 # F2 Key
   F3                  = 0x72 # F3 Key
   F4                  = 0x73 # F4 Key
   F5                  = 0x74 # F5 Key
   F6                  = 0x75 # F6 Key
   F7                  = 0x76 # F7 Key
   F8                  = 0x77 # F8 Key
   F9                  = 0x78 # F9 Key
   F10                 = 0x79 # F10 Key
   F11                 = 0x7A # F11 Key
   F12                 = 0x7B # F12 Key
   F13                 = 0x7C # F13 Key
   F14                 = 0x7D # F14 Key
   F15                 = 0x7E # F15 Key
   F16                 = 0x7F # F16 Key
   F17                 = 0x80 # F17 Key
   F18                 = 0x81 # F18 Key
   F19                 = 0x82 # F19 Key
   F20                 = 0x83 # F20 Key
   F21                 = 0x84 # F21 Key
   F22                 = 0x85 # F22 Key
   F23                 = 0x86 # F23 Key
   F24                 = 0x87 # F24 Key
   #--------------------------------------------------------------------------
   # * Chaves alternativas
   #--------------------------------------------------------------------------
   CAPITAL             = 0x14 # Caps Lock Key
   KANA                = 0x15 # IME Kana Mode Key
   HANGUL              = 0x15 # IME Hangul Mode Key
   JUNJA               = 0x17 # IME Junja Mode Key
   FINAL               = 0x18 # IME Final Mode Key
   HANJA               = 0x19 # IME Hanja Mode Key
   KANJI               = 0x19 # IME Kanji Mode Key
   MODECHANGE          = 0x1F # IME Mode Change Request Key
   INSERT              = 0x2D # Insert Key
   NUMLOCK             = 0x90 # Num Lock Key
   SCROLL              = 0x91 # Scroll Lock Key
   #--------------------------------------------------------------------------
   # * Chaves OEM, variadas
   #--------------------------------------------------------------------------
   OEM_1               = 0xBA # Misc Characters (; : in USA 101/102 Keyboards)
   OEM_PLUS            = 0xBB # + = Key
   OEM_COMMA           = 0xBC # , < Key
   OEM_MINUS           = 0xBD # - _ Key
   OEM_PERIOD          = 0xBE # . > Key
   OEM_2               = 0xBF # Misc Characters (/ ? in USA 101/102 Keyboards)
   OEM_3               = 0xC0 # Misc Characters (` ~ in USA 101/102 Keyboards)
   OEM_4               = 0xDB # Misc Characters ([ { in USA 101/102 Keyboards)
   OEM_5               = 0xDC # Misc Characters (\ | in USA 101/102 Keyboards)
   OEM_6               = 0xDD # Misc Characters (] } in USA 101/102 Keyboards)
   OEM_7               = 0xDE # Misc Characters (' " in USA 101/102 Keyboards)
   OEM_8               = 0xDF # Misc Characters (Varies by Keyboard)
   OEM_9               = 0xE1 # OEM Specific
   OEM_10              = 0x92 # OEM Specific
   OEM_11              = 0x93 # OEM Specific
   OEM_12              = 0x94 # OEM Specific
   OEM_13              = 0x95 # OEM Specific
   OEM_14              = 0x96 # OEM Specific
   OEM_15              = 0xE3 # OEM Specific
   OEM_16              = 0xE4 # OEM Specific
   OEM_17              = 0xE6 # OEM Specific
   OEM_18              = 0xE9 # OEM Specific
   OEM_19              = 0xEA # OEM Specific
   OEM_20              = 0xEB # OEM Specific
   OEM_21              = 0xEC # OEM Specific
   OEM_22              = 0xED # OEM Specific
   OEM_23              = 0xEE # OEM Specific
   OEM_24              = 0xEF # OEM Specific
   OEM_25              = 0xF1 # OEM Specific
   OEM_26              = 0xF2 # OEM Specific
   OEM_27              = 0xF3 # OEM Specific
   OEM_28              = 0xF4 # OEM Specific
   OEM_29              = 0xF5 # OEM Specific
   OEM_102             = 0xE2 # Angle Bracket or Backslash on RT-102 Keyboards
   OEM_CLEAR           = 0xFE # Clear Key
   #--------------------------------------------------------------------------
   # * Variáveis do módulo.
   #--------------------------------------------------------------------------
   @unpack_string = 'b'*256
   @last_array = '0'*256
   @press = Array.new(256, false)
   @trigger = Array.new(256, false)
   @repeat = Array.new(256, false)
   @release = Array.new(256, false)
   @repeat_counter = Array.new(256, 0)
   @getKeyboardState = API::GetKeyboardState
   @getAsyncKeyState = API::GetAsyncKeyState
   @getKeyboardState.call(@last_array)
   @last_array = @last_array.unpack(@unpack_string)
   for i in 0...@last_array.size
     @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true
   end
   #--------------------------------------------------------------------------
   # * Atualização dos objetos do módulo.
   #--------------------------------------------------------------------------
   def update
     @trigger = Array.new(256, false)
     @repeat = Array.new(256, false)
     @release = Array.new(256, false)
     array = '0'*256
     @getKeyboardState.call(array)
     array = array.unpack(@unpack_string)
     for i in 0...array.size
       if array[i] != @last_array[i]
         @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true
         if @repeat_counter[i] <= 0 && @press[i]
           @repeat[i] = true
           @repeat_counter[i] = 15
         end
         if !@press[i]
           @release[i] = true
         else
           @trigger[i] = true
         end
       else
         if @press[i] == true
           @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true
           @release[i] = true if !@press[i]
         end
         if @repeat_counter[i] > 0 && @press[i] == true
           @repeat_counter[i] -= 1
         elsif @repeat_counter[i] <= 0 && @press[i] == true
           @repeat[i] = true
           @repeat_counter[i] = 3
         elsif @repeat_counter[i] != 0
           @repeat_counter[i] = 0
         end
       end
     end
     @last_array = array
   end
   #--------------------------------------------------------------------------
   # * Get Key Pressed State
   #     key : key index
   #--------------------------------------------------------------------------
   def press?(key)
     return @press[key]
   end
   #--------------------------------------------------------------------------
   # * Get Key Triggered State
   #     key : key index
   #--------------------------------------------------------------------------
   def trigger?(key)
     return @trigger[key]
   end
   #--------------------------------------------------------------------------
   # * Get Key Repeated State
   #     key : key index
   #--------------------------------------------------------------------------
   def repeat?(key)
     return @repeat[key]
   end
   #--------------------------------------------------------------------------
   # * Get Key Released State
   #     key : key index
   #--------------------------------------------------------------------------
   def release?(key)
     return @release[key]
   end
   #----------------------------------------------------------------------------
   # • CONSTANTES.
   #----------------------------------------------------------------------------
   AZ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(//)
   @az = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".downcase!.split(//)
   NUM = "0123456789".split(//)
   @@string_char = @@string_num = @@string_az = ""
   @@string = ""
   #----------------------------------------------------------------------------
   # • Retornar a String correspondente a tecla pressionada dos números.
-  @@AZ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(//)
+
-  @@az = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".downcase!.split(//)
+
-  @@NUM = "0123456789".split(//)
+
     numpad = "NUMPAD0,NUMPAD1,NUMPAD2,NUMPAD3,NUMPAD4,NUMPAD5,NUMPAD6,NUMPAD7,NUMPAD8,NUMPAD9".split(',')
     n.each_with_index { |v,i| eval("return NUM[i] if #{input}(#{v})") }
     numpad.each_with_index { |v,i| eval("return NUM[i] if #{input}(#{v})") }
     return ""
   end
   #----------------------------------------------------------------------------
   # • Retorar a String correspondente a tecla pressionada dos alfabeto
   #----------------------------------------------------------------------------
-    n.each_with_index { |v,i| eval("return @@NUM[i] if #{input}(#{v})") }
+
-    numpad.each_with_index { |v,i| eval("return @@NUM[i] if #{input}(#{v})") }
+
       AZ.each_with_index { |v,i| eval("return AZ[i] if #{input}(#{v})") }
     else
       AZ.each_with_index { |v,i| eval("return @az[i] if #{input}(#{v})") }
     end
     return ""
   end
   #----------------------------------------------------------------------------
-      @@AZ.each_with_index { |v,i| eval("return @@AZ[i] if #{input}(#{v})") }
+
   #----------------------------------------------------------------------------
-      @@AZ.each_with_index { |v,i| eval("return @@az[i] if #{input}(#{v})") }
+
     @@string_num = self.stringNUM(input)
     @@string_az = self.stringAZ(input)
     @@string = @@string_num + @@string_az
     @@string += " " if trigger?(SPACE)
     return @@string
   end
 end
 #==============================================================================
 # • Sprite
 #==============================================================================
 Dax.register(:sprite)
 class Sprite
   #----------------------------------------------------------------------------
   # • Variáveis públicas da instância.
   #----------------------------------------------------------------------------
   attr_accessor :clone_sprite
   #----------------------------------------------------------------------------
   # • Novo método. Modos de usos abaixo:
   #  * [normal] : É o método normal, na qual você não define nada. Sprite.new
   #  * [viewport] : É o método na qual você define um viewport.
   # Sprite.new(Viewport)
   #  * [system] : É o método na qual você já define um bitmap que irá carregar
   # uma imagem já direto da pasta System, através do Cache.
   # Sprite.new("S: Nome do Arquivo")
   #  * [picture] : É o método na qual você já define um bitmap que irá carregar
   # uma imagem já direito da pasta Pictures, através do Cache.
   # Sprite.new("P: Nome do Arquivo")
   #  * [graphics] : É o método na qual você já define um bitmap com uma imagem
   # que está dentro da pasta Graphics, através do Cache.
   # Sprite.new("G: Nome do Arquivo.")
   #  * [width, height] : É o método na qual você já define a largura e altura
   # do bitmap. Sprite.new([width, height])
   #  * [elements] : É o método na qual você já define a largura, altura,
   # posição X, posição Y e Prioridade do bitmap.
   # Sprite.new([width, height, x, y, z])
   #----------------------------------------------------------------------------
   alias new_initialize initialize
   def initialize(viewport=nil)
     @clone_sprite = []
     if viewport.is_a?(String)
       new_initialize(nil)
       if viewport.match(/S: ([^>]*)/)
         self.bitmap = Cache.system($1.to_s)
       elsif viewport.match(/P: ([^>]*)/)
         self.bitmap = Cache.picture($1.to_s)
       elsif viewport.match(/G: ([^>]*)/)
         self.bitmap = Cache.load_bitmap("Graphics/", $1.to_s)
       else
         self.bitmap = Bitmap.new(viewport)
       end
     elsif viewport.is_a?(Array)
       if viewport.size == 2
         new_initialize(nil)
         self.bitmap = Bitmap.new(viewport[0], viewport[1])
       elsif viewport.size == 5
         new_initialize(nil)
         self.bitmap = Bitmap.new(viewport[0], viewport[1])
         self.x, self.y, self.z = viewport[2], viewport[3], viewport[4]
       end
     elsif viewport.is_a?(Viewport) or viewport.nil?
       new_initialize(viewport)
     end
   end
   #----------------------------------------------------------------------------
   # • Slide pela direita.
   #   * speed : Velocidade | point : Ponto da coordenada X que irá chegar.
   #----------------------------------------------------------------------------
   def slide_right(speed, point)
     self.x += speed unless self.x >= point
   end
   #----------------------------------------------------------------------------
   # • Slide pela esquerda.
   #   * speed : Velocidade | point : Ponto da coordenada X que irá chegar.
   #----------------------------------------------------------------------------
   def slide_left(speed, point)
     self.x -= speed unless self.x <= point
   end
   #----------------------------------------------------------------------------
   # • Slide por cima.
   #   * speed : Velocidade | point : Ponto da coordenada Y que irá chegar.
   #----------------------------------------------------------------------------
   def slide_up(speed, point)
     self.y -= speed unless self.y <= point
   end
   #----------------------------------------------------------------------------
   # • Slide por baixo.
   #   * speed : Velocidade | point : Ponto da coordenada Y que irá chegar.
   #----------------------------------------------------------------------------
   def slide_down(speed, point)
     self.y += speed unless self.y >= point
   end
   #----------------------------------------------------------------------------
   # • Define aqui uma posição fixa para um objeto.
   #   command : Retorna a uma base padrão.
   #----------------------------------------------------------------------------
   def position(command=0)
     return if command.nil?
     case command
     # Imagem ficará no canto esquerdo superior. Posição X
     when 0 then self.x = 0
     # A posição X ficará no centro da tela.
     when 1 then self.x = DMath.get_x_center_screen(self.width)
     # A posição X ficará no canto direito superior.
     when 2 then self.x = Graphics.width - self.width
     # A posição Y ficará no canto esquerdo inferior.
     when 3 then self.y = 0
     # Posicionar o Y para ficar no centro.
     when 4 then self.y = DMath.get_y_center_screen(self.height)
     # Posicionar o Y para ficar no fundo da tela.
     when 5 then self.y = Graphics.height - self.height
     # Posicionar a imagem no centro da tela.
     when :center
       self.x = (Graphics.width - self.width) / 2
       self.y = Graphics.height / 2 - self.height / 2
     # Posicionar no centro esquerdo da tela.
     when :center_left
       self.x = 0
       self.y = (Graphics.height - self.height) / 2
     # Posicionar no centro direito da tela.
     when :center_right
       self.x = Graphics.width - self.height
       self.y = (Graphics.height - self.height) / 2
     end
   end
   #----------------------------------------------------------------------------
   # • Tamanho geral
   #----------------------------------------------------------------------------
   def size
     return self.width + self.height
   end
   #----------------------------------------------------------------------------
   # • Retorna ao Rect do Bitmap.
   #----------------------------------------------------------------------------
   def rect
     return self.bitmap.rect
   end
   #----------------------------------------------------------------------------
   # • Base para clonar um Sprite.
-  # • Rect
+
   #    * clone_bitmap : Se irá clonar o bitmap.
   # Exemplo: sprite = sprite2.clone
   #----------------------------------------------------------------------------
   def clone(depht=0, clone_bitmap=false)
     @clone_sprite.delete_if { |bitmap| bitmap.disposed? }
     cloned = Sprite.new(self.viewport)
     cloned.x, cloned.y = self.x, self.y
     cloned.bitmap = self.bitmap
     cloned.bitmap = self.bitmap.clone if clone_bitmap
     unless depht == 0
       cloned.z = self.z + depht
     else
       @clone_sprite.each { |sprite| sprite.z -= 1 }
       cloned.z = self.z - 1
     end
     cloned.src_rect.set(self.src_rect)
     ["zoom_x", "zoom_y", "angle", "mirror", "opacity", "blend_type", "visible",
      "ox", "oy"].each { |meth|
       eval("cloned.#{meth} = self.#{meth}")
     }
     cloned.color.set(color)
     cloned.tone.set(tone)
     after_clone(cloned)
     @clone_sprite.push(cloned)
     return cloned
   end
   #----------------------------------------------------------------------------
   # • Efeito após ter clonado o Sprite.
   #----------------------------------------------------------------------------
   def after_clone(clone)
   end
   #----------------------------------------------------------------------------
   # • O que irá acontecer sê o mouse estiver em cima do sprite?
   #----------------------------------------------------------------------------
   def mouse_over
   end
   #----------------------------------------------------------------------------
   # • O que irá acontecer sê o mouse não estiver em cima do sprite?
   #----------------------------------------------------------------------------
   def mouse_no_over
   end
   #----------------------------------------------------------------------------
   # • O que irá acontecer sê o mouse clicar no objeto
   #----------------------------------------------------------------------------
   def mouse_click
   end
   #----------------------------------------------------------------------------
   # • Atualização dos sprites.
   #----------------------------------------------------------------------------
   alias :dax_update :update
   def update(*args, &block)
     dax_update(*args, &block)
     unless Mouse.cursor.nil?
       self.if_mouse_over { |over| over ? mouse_over : mouse_no_over }
       self.if_mouse_click { mouse_click }
     end
   end
 end
 #==============================================================================
 # • Bitmap
 #==============================================================================
 Dax.register(:bitmap)
 class Bitmap
   #----------------------------------------------------------------------------
   # • *** Método ainda não explicado ***
   #----------------------------------------------------------------------------
   def draw_paragraph(x, y, width, height, text, align=0)
     text = text.split(/\n/)
     text.size.times { |i| self.draw_text(x, y+((self.font.size+1) * i), width,
      height, text[i].to_s, align)
     }
   end
   #----------------------------------------------------------------------------
   # • Criar uma barra.
   #    color : Objeto de Cor [Color]
   #    actual : Valor atual da barra.
   #    max : Valor máximo da barra.
   #    borda : Tamanho da borda da barra.
   #----------------------------------------------------------------------------
   def bar(color, actual, max, borda=1)
     rate = self.width.to_p(actual, max)
     self.fill_rect(borda, borda, rate-(borda*2), self.height-(borda*2),
     color)
   end
   #----------------------------------------------------------------------------
   # • Barra em forma de gradient.
   #    color : Objeto de Cor, em forma de [Array] para conter 2 [Color]
   # exemplo -> [Color.new(x), Color.new(y)]
   #    actual : Valor atual da barra.
   #    max : Valor máximo da barra.
   #    borda : Tamanho da borda da barra.
   #----------------------------------------------------------------------------
   def gradient_bar(color, actual, max, borda=1)
     rate = self.width.to_p(actual, max)
     self.gradient_fill_rect(borda, borda, rate-(borda*2), self.height-(borda*2),
     color[0], color[1], 2)
   end
   #----------------------------------------------------------------------------
   # • Efeito de Shader Sill
   #----------------------------------------------------------------------------
   def shader_sill
     ra = 500
     re = 0 ; gr = 0 ; bl = 0
     for i in 1..(self.height-1)
       for j in 1..(self.width-1)
         for m in -1..1
           for n in -1..1
             if m != 0 and n != 0
               a = self.get_pixel(j+m,i+n)
               re = re + a.red
               gr = gr + a.green
               bl = bl + a.blue
             end
           end
         end
         b = self.get_pixel(j,i)
         re = (b.red-re/8).abs
         gr = (b.green-gr/8).abs
         bl = (b.blue-bl/8).abs
         self.set_pixel(j,i,Color.new(0, 0, 0, b.alpha) )
       end
     end
   end
   #--------------------------------------------------------------------------
   # * Desenho do gráfico do personagem
   #     character_name  : nome do gráfico do personagem
   #     character_index : índice do gráfico de personagem
   #     x               : coordenada X
   #     y               : coordenada Y
   #--------------------------------------------------------------------------
   def draw_character(character_name, character_index, x, y)
     return unless character_name
     bitmap = Cache.character(character_name)
     sign = character_name[/^[\!\$]./]
     if sign && sign.include?('$')
       cw = bitmap.width / 3
       ch = bitmap.height / 4
     else
       cw = bitmap.width / 12
       ch = bitmap.height / 8
     end
     n = character_index
     src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
     self.blt(x - cw / 2, y - ch, bitmap, src_rect)
   end
   #--------------------------------------------------------------------------
   # * Desenho do gráfico de personagem do herói
   #     actor : herói
   #     x     : coordenada X
   #     y     : coordenada Y
   #--------------------------------------------------------------------------
   def draw_actor_graphic(actor, x, y)
     draw_character(actor.character_name, actor.character_index, x, y)
   end
   #----------------------------------------------------------------------------
   # • Limpar uma área num formato de um círculo.
   #----------------------------------------------------------------------------
   def clear_rect_circle(x, y, r)
     rr = r*r
     for i in 0...r
       adj = Math.sqrt(rr - (i*i)).ceil
       xd = x - adj
       wd = 2 * adj
       self.clear_rect(xd, y-i, wd, 1)
       self.clear_rect(xd, y+i, wd, 1)
     end
   end
   #----------------------------------------------------------------------------
   # • Novo modo de desenhar textos. Configurações já especificadas.
   #----------------------------------------------------------------------------
   def draw_text_rect(*args)
     self.draw_text(self.rect, *args)
   end
   #----------------------------------------------------------------------------
   # • Salvar em png.
   #   --- Autor : Gab! ---
   #----------------------------------------------------------------------------
   def save(file_name)
     def chunk(type, data)
       [data.size, type, data, Zlib.crc32(type + data)].pack("NA4A*N")
     end
     img_data = ""
     width, height = self.width, self.height
     for j in 0...(height)
       img_data << "\0"
       for i in 0...(width)
         pos_c = self.get_pixel(i, j)
         img_data << [pos_c.red, pos_c.green, pos_c.blue, pos_c.alpha].pack("C*")
       end
     end
     c = [
       "\x89PNG\r\n\x1a\n",
       chunk("IHDR", [width, height, 8, 6, 0, 0, 0].pack("N2C5")),
       chunk("IDAT", Zlib::Deflate.deflate(img_data)),
       chunk("IEND", "")
     ]
     File.open(file_name, "wb"){|file| c.each{|chunk| file.write(chunk) }}
   end
   #----------------------------------------------------------------------------
   # • Modificar as cores do [Bitmap] para ficarem Negativas.
   #----------------------------------------------------------------------------
   def negative
     for i in 0...(self.width)
       for j in 0...(self.height)
         pix = self.get_pixel(i, j)
         pix.red = (pix.red - 255) * -1
         pix.blue = (pix.blue - 255) * -1
         pix.green = (pix.green - 255) * -1
         self.set_pixel(i, j, pix)
       end
     end
   end
   #----------------------------------------------------------------------------
   # • Grayscale : Modificar as cores do [Bitmap] para cor cinza.
   #----------------------------------------------------------------------------
   def grayscale(rect = Rect.new(0, 0, self.width, self.height))
     for i in rect.x...rect.x + rect.width
       for j in rect.y...rect.y + rect.height
         colour = self.get_pixel(i,j)
         grey_pixel = (colour.red*0.3 + colour.green*0.59 + colour.blue*0.11)
         colour.red = colour.green = colour.blue = grey_pixel
         self.set_pixel(i,j,colour)
       end
     end
   end
   #----------------------------------------------------------------------------
   # • Novo fornecedor de pixel.
   #----------------------------------------------------------------------------
   def set_pixel_s(x, y, color, size)
     for i in 0...size
       self.set_pixel(x+i, y, color)
       self.set_pixel(x-i, y, color)
       self.set_pixel(x, y+i, color)
       self.set_pixel(x, y-i, color)
       self.set_pixel(x+i, y+i, color)
       self.set_pixel(x-i, y-i, color)
       self.set_pixel(x+i, y-i, color)
       self.set_pixel(x-i, y+i, color)
     end
   end
   #----------------------------------------------------------------------------
   # • Desenhar uma linha.
   #    start_x : Início da linha em X.
   #    start_y : Início da linha em Y.
   #    end_x : Finalização da linha em X.
   #    end_y : Finalização da linha em Y.
   #----------------------------------------------------------------------------
   def draw_line(start_x, start_y, end_x, end_y, color, size=1)
     set_pixel_s(start_x, start_y, color, size)
     distance = (start_x - end_x).abs + (start_y - end_y).abs
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       set_pixel_s(x, y, color, size)
     end
     set_pixel_s(end_x, end_y, color, size)
   end
   #----------------------------------------------------------------------------
   # • draw_bar_gauge(x, y, current, current_max, border, colors)
   #   x : Coordenadas X.
   #   y : Coordenadas Y.
   #   current : Valor atual da barra.
   #   current_max : Valor maxímo da barra.
   #   border : Expressura da borda.
   #   colors : Cores. [0, 1, 2]
   #----------------------------------------------------------------------------
   #  Permite adicionar uma barra.
   #----------------------------------------------------------------------------
   def draw_bar_gauge(x, y, current, current_max, colors=[])
     cw = self.width.to_p(current, current_max)
     ch = self.height
     self.gradient_fill_rect(x, y, self.width, self.height, colors[0], colors[1])
     src_rect = Rect.new(0, 0, cw, ch)
     self.blt(x, y, self, src_rect)
   end
   #----------------------------------------------------------------------------
   # • draw_icon(icon_index, x, y, enabled)
   #   icon_index : ID do ícone.
   #   x : Coordenadas X.
   #   y : Coordenadas Y.
   #   enabled : Habilitar flag, translucido quando false
   #----------------------------------------------------------------------------
   #----------------------------------------------------------------------------
   def draw_icon(icon_index, x, y, enabled = true)
     icon_index = icon_index.nil? ? 0 : icon_index
     bitmap = Cache.system("Iconset")
     rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
     self.blt(x, y, bitmap, rect, enabled ? 255 : 128)
   end
   #----------------------------------------------------------------------------
   # • draw_gradation_gauge(x, y, width, height, current, current_max, border, colors, align)
   #   x : Coordenadas X.
   #   y : Coordenadas Y.
   #   width : Largura da barra.
   #   height : Altura da barra.
   #   current : Valor atual da barra.
   #   current_max : Valor maxímo da barra.
   #   border : Expressura da borda.
   #   colors : Cores. [0, 1, 2]
   #   align : Alinhamento.
   #----------------------------------------------------------------------------
   #  Permite adicionar uma barra.
   #----------------------------------------------------------------------------
   def draw_gradation_gauge(x, y, current, current_max, border, colors=[])
     cw = self.width.to_p(current, current_max)
     ch = self.height
     self.fill_rect(x, y, self.width, self.height, colors[0])
     self.gradient_fill_rect(x+border, y+border, self.width-(border/2), self.height-(border/2), colors[1], colors[2])
     src_rect = Rect.new(0, 0, cw, ch)
     self.blt(x, y, self, src_rect)
   end
   #--------------------------------------------------------------------------
   # • Desenho do gráfico de rosto
   #     face_name  : nome do gráfico de face
   #     face_index : índice do gráfico de face
   #     x          : coordenada X
   #     y          : coordenada Y
   #     enabled    : habilitar flag, translucido quando false
   #--------------------------------------------------------------------------
   def draw_face(face_name, face_index, x, y, enabled = true)
     bitmap = Cache.face(face_name)
     rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
     self.blt(x, y, bitmap, rect, enabled ? 255 : 128)
   end
   #--------------------------------------------------------------------------
   # • Desenho do gráfico de face do herói
   #     actor   : herói
   #     x       : coordenada X
   #     y       : coordenada Y
   #     enabled : habilitar flag, translucido quando false
   #--------------------------------------------------------------------------
   def draw_actor_face(actor, x, y, enabled = true)
     draw_face(actor.face_name, actor.face_index, x, y, enabled)
   end
   #--------------------------------------------------------------------------
   # • Desenho do nível
   #     actor : herói
   #     x     : coordenada X
   #     y     : coordenada Y
   #--------------------------------------------------------------------------
   def draw_actor_level(actor, x, y)
     self.font.name = "Comic Sans MS"
     self.font.color = ColorBasic[35]
     self.font.size = 18
     self.draw_text(x, y, 32, 20, Vocab::level_a)
     self.font.size = 22
     draw_text(x + 16, y, 32, 20, actor.level, 2)
   end
   #----------------------------------------------------------------------------
   # • Desenhar um círuclo preenchido.
   #----------------------------------------------------------------------------
   def fill_circle(x, y, r, c)
     rr = r*r
     for i in 0...r
       adj = Math.sqrt(rr - (i*i)).ceil
       xd = x - adj
       wd = 2 * adj
       self.fill_rect(xd, y-i, wd, 1, c)
       self.fill_rect(xd, y+i, wd, 1, c)
     end
   end
   #----------------------------------------------------------------------------
   # • Desenhar um triângulo preenchido
   #----------------------------------------------------------------------------
   def fill_triangle3(pts, c, pos=[0, 0])
     return if pts.size != 3
     pts.sort! {|a, b| a[1] - b[1]}
     pt1, pt2, pt3 = pts
     dxt = (pt3[0] - pt1[0]) / 2
     dyt = (pt3[1] - pt1[1]) / 2
     dxm = pt2[0] - pt1[0]
     dym = pt2[1] - pt1[1]
     dm = dym.abs
     if dm > 0 and dyt != 0
       for i in 0...(dm+2)
         ix = ((dxm*i) / (dm+1))
         iy = ((dym*i) / (dm+1))
         edx = ix - (dxt * iy / dyt)
         self.fill_rect(ix+pt1[0]-[edx,0].max-2+pos[0], iy+pt1[1]+pos[1], edx.abs+4, 1, c)
       end
     end
     dxm = pt2[0] - pt3[0]
     dym = pt2[1] - pt3[1]
     dm = dym.abs
     if dm > 0 and dyt != 0
       for i in 0...(dm+2)
         ix = ((dxm*i) / (dm+1))
         iy = ((dym*i) / (dm+1))
         edx = ix - (dxt * iy / dyt)
         self.fill_rect(ix+pt3[0]-[edx,0].max-2+pos[0], iy+pt3[1]+pos[1], edx.abs+4, 1, c)
       end
     end
   end
   #----------------------------------------------------------------------------
   # • Desenhar um polígono.
   #----------------------------------------------------------------------------
   def fill_polygon(pts, c, pos=[0, 0])
     return if pts.size <= 2
     n = pts.size - 2
     for i in 0...n
       self.fill_triangle3(pts[i..(i + 2)], c, pos)
     end
   end
 end
 #==============================================================================
 # • Mouse
 #==============================================================================
 Dax.register(:mouse)
 module Mouse
   extend self
   #--------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #--------------------------------------------------------------------------
   def start
     @cursor = Sprite.new
     @cursor.z = 100000
     @cursor.bitmap = Bitmap.new(1, 1)
     x = Dax::Mouse_Name == "" ? 1 : 0
     API::MouseShowCursor.call(x)
     @dgraphic = Dax::Mouse_Name
     graphic Dax::Mouse_Name
     @old_graphic = @dgraphic
     update
   end
   #----------------------------------------------------------------------------
   # • visible = (boolean)
   #  * boolean : true ou false
   # Tornar vísivel ou não o cursor do Mouse.
   #----------------------------------------------------------------------------
   def visible=(boolean)
     API::MouseShowCursor.call(boolean.boolean)
   end
   #--------------------------------------------------------------------------
   # • graphic(graphic_set)
   #   graphic_set : Se for número é um ícone; Se for string é uma imagem.
   #--------------------------------------------------------------------------
   def graphic(graphic_set)
-    API::MouseShowCursor.call(boolean.visible.boolean_number)
+    return unless graphic_set == "" or graphic_set.nil?
     set_graphic
     @dgraphic = graphic_set
   end
   #--------------------------------------------------------------------------
   # • show(visible)
   #   visible : True - para mostrar o mouse | False - para esconder o mouse.
-    return if graphic_set == "" or graphic_set.nil?
+
   def show(visible=true)
     @cursor.visible = visible
   end
   #--------------------------------------------------------------------------
   # • update (Atualização das coordenadas)
   #--------------------------------------------------------------------------
   def update
     return if @cursor.nil?
     @cursor.x, @cursor.y = position
   end
   #----------------------------------------------------------------------------
   # • Mudança do gráfico.
   #----------------------------------------------------------------------------
   def set_graphic
     unless @old_graphic == @dgraphic
       if @dgraphic.is_a?(Fixnum)
         @cursor.bitmap = Bitmap.new(24, 24)
         @cursor.bitmap.draw_icon(@dgraphic.to_i, 0, 0)
       else
         @cursor.bitmap = Cache.picture(@dgraphic.to_s)
       end
       @old_graphic = @dgraphic
     end
   end
   #--------------------------------------------------------------------------
   # • Retorna a variável '@cursor' que tem como valor a classe [Sprite].
   #--------------------------------------------------------------------------
   def cursor
     @cursor
   end
   #--------------------------------------------------------------------------
   # • x (Coordenada X do Mouse)
   #--------------------------------------------------------------------------
   def x
     @cursor.x
   end
   #--------------------------------------------------------------------------
   # • y (Coordenada Y do Mouse)
   #--------------------------------------------------------------------------
   def y
     @cursor.y
   end
   #----------------------------------------------------------------------------
   # • Elementos das coordenadas do mouse.
   #----------------------------------------------------------------------------
   def eachPos
     yield x
     yield y
     yield @cursor.z
   end
   #--------------------------------------------------------------------------
   # • position (Posição do Mouse!)
-  def eachPos(&block)
+
-    return unless block_given?
+
     x, y = get_client_position
     return x, y
   end
   #--------------------------------------------------------------------------
   # • get_client_position (Posição original do Mouse!)
   #--------------------------------------------------------------------------
   def get_client_position
     pos = [0, 0].pack('ll')
     API::CursorPosition.call(pos)
     API::ScreenToClient.call(WINDOW, pos)
     return pos.unpack('ll')
   end
   #--------------------------------------------------------------------------
   # • find_window (Tamanho da window)
   #--------------------------------------------------------------------------
   def find_window
     game_name = '\0' * 256
     API::ReadIni.call('Game', 'Title', '', game_name, 255, '.\\Game.ini')
     game_name.delete!('\0') ensure game_name
     return API::FindWindow.call('RGSS Player', game_name)
   end
   #--------------------------------------------------------------------------
   # • Verificação se o mouse está na área de um determinado objeto.
   #--------------------------------------------------------------------------
   def in_area?(object_sprite)
     return @cursor.x.between?(object_sprite.x, object_sprite.x + object_sprite.width) &&
       @cursor.y.between?(object_sprite.y, object_sprite.y + object_sprite.height)
   end
   #----------------------------------------------------------------------------
   # • Verificar se o mouse está em determinada área
   #----------------------------------------------------------------------------
   def area?(x, y, width, height)
     return @cursor.x.between?(x, x + width) &&
       @cursor.y.between?(y, y + height)
   end
   #----------------------------------------------------------------------------
   # • Mudar posição do cursor.
   #----------------------------------------------------------------------------
   def set_mouse(pos)
     SetCursorPos.call(pos.x, pos.y)
     update
     @cursor.x = @pos.x
     @cursor.y = @pos.y
   end
   WINDOW = find_window
 end
 
 #==============================================================================
 # • Object
 #==============================================================================
 Dax.register(:object)
 class Object
   #----------------------------------------------------------------------------
   # • O que irá ocorrer caso o mouse esteja sobre uma sprite.
   # Tem que ser um objeto Sprite. EXPLICAÇÕES NO FINAL DO SCRIPT.
   #----------------------------------------------------------------------------
   def if_mouse_over(&block)
     return if Mouse.cursor.nil?
     return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given?
     over ||= false
     if Mouse.in_area?(self)
       block.call
       over = true
     else
       over = false
     end
     yield over
   end
   #----------------------------------------------------------------------------
   # • Retorna no bloco os nomes e quantidade de cada arquivo. Mais o nome
   # separado. Mais o tipo de cada elemento.
   #  "Nome da Pasta".dirGlob { |filename, size| }
   #----------------------------------------------------------------------------
   def dirGlob
     return unless self.is_a?(String) or File.directory?(self)
     dir = Dir.glob(self.include?("/") ? self + "*" : self + "/*")
     yield dir
     yield dir.size
   end
   #----------------------------------------------------------------------------
   # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao clicar.
   # Tem que ser um objeto Sprite.
   #  * button : Button : (:right - botão direito do mouse | :left - botão esq.)
   # EXPLICAÇÕES NO FINAL DO SCRIPT.
   #----------------------------------------------------------------------------
   def if_mouse_click(button=:left, &block)
     return if Mouse.cursor.nil?
     return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given?
     button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01
     block.call if Mouse.in_area?(self)  and trigger?(button)
   end
   #----------------------------------------------------------------------------
   # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao pressionar.
   # Tem que ser um objeto Sprite.
   #  * button : Button : (:right - botão direito do mouse | :left - botão esq.)
   #----------------------------------------------------------------------------
   def if_mouse_press(button=:left, &block)
     return if Mouse.cursor.nil?
     return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given?
     button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01
     block.call if Mouse.in_area?(self)  and press?(button)
   end
   #----------------------------------------------------------------------------
   # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao ficar clicando.
   # Tem que ser um objeto Sprite.
   #  * button : Button : (:right - botão direito do mouse | :left - botão esq.)
   #----------------------------------------------------------------------------
   def if_mouse_repeat(button=:left, &block)
     return if Mouse.cursor.nil?
     return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given?
     button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01
     block.call if Mouse.in_area?(self)  and repeat?(button)
   end
   #----------------------------------------------------------------------------
   # • Trigger
   #  * key : Chave.
   # Você também pode usá-lo como condição para executar tal bloco;
   #----------------------------------------------------------------------------
   # trigger?(key) { bloco que irá executar }
   #----------------------------------------------------------------------------
   def trigger?(key, &block)
     ckey = key.is_a?(Symbol) ? Input.trigger?(key) : Key.trigger?(key)
     return ckey unless block_given?
     block.call if ckey
   end
   #----------------------------------------------------------------------------
   # • Press
   #  * key : Chave.
   # Você também pode usá-lo como condição para executar tal bloco;
   #----------------------------------------------------------------------------
   # press?(key) { bloco que irá executar. }
   #----------------------------------------------------------------------------
   def press?(key, &block)
     ckey = key.is_a?(Symbol) ? Input.press?(key) : Key.press?(key)
     return ckey unless block_given?
     block.call if ckey
   end
   #----------------------------------------------------------------------------
   # • Repeat
   #  * key : Chave.
   # Você também pode usá-lo como condição para executar tal bloco;
   #----------------------------------------------------------------------------
   # repeat?(key) { bloco que irá executar. }
   #----------------------------------------------------------------------------
   def repeat?(key)
     ckey = key.is_a?(Symbol) ? Input.repeat?(key) : Key.repeat?(key)
     return ckey unless block_given?
     block.call if ckey
   end
   #----------------------------------------------------------------------------
   # • Retorna em forma de número os valores true ou false. E caso seja
   # 0 ou 1.. retorna a true ou false.
   # Se for true, retorna a 1.
   # Se for false, retorna a 0.
   # Se for 1, retorna a true.
   # Se for 0, retorna a false.
   #----------------------------------------------------------------------------
   def boolean
     return self.is_a?(Integer) ? self == 0 ? false : 1  : self ? 1 : 0
   end
   #----------------------------------------------------------------------------
   # • Converte para a classe Position.
   #----------------------------------------------------------------------------
   def position
     return Position.new(self, self) if self.is_class?(Numeric)
     return Position.new(self.x, self.y) if self.is_class?(Sprite) or self.is_class?(Window_Base)
     return Position.new(0, 0)
   end
   #----------------------------------------------------------------------------
   # • Transforma em cor.
   #  Se for uma Array. Exemplo: [128, 174, 111].color =># Color.new(128, 174, 111)
   #  Se for uma String. Exemplo: "ffffff".color =># Color.new(255,255,255)
   #  Se for um número, aí retorna a uma cor de acordo com o Index do ColorBasic.
   #----------------------------------------------------------------------------
   def color
     return Color.new(*self) if self.is_a?(Array)
     return ColorBasic.hex(self) if self.is_a?(String)
     return ColorBasic[self] if self.is_a?(Integer)
   end
 end
 #==============================================================================
 # • Entries *** Classe ainda não explicada ******
 #==============================================================================
 Dax.register(:entries)
 class Entries
   #----------------------------------------------------------------------------
   # • Variável pública da instância.
   #----------------------------------------------------------------------------
   attr_accessor :file
   attr_reader   :get_number
   attr_reader   :get_file
   attr_reader   :get_array
   attr_reader   :name
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(directory, typefile)
     return unless FileTest.directory?(directory)
     @file = Dir.glob(directory + "/*.{" + typefile + "}")
     @file.each_index { |i| @get_number = i.to_i }
     @file.each { |i| @get_file = i.to_s }
     @file.each_with_index { |i| @get_array = i }
     @name = split @file[0]
   end
   #----------------------------------------------------------------------------
   # • Split | Separar
   #----------------------------------------------------------------------------
   def split(file)
     file.to_s.split('/').last
   end
   #----------------------------------------------------------------------------
   # • Obter nome.
   #----------------------------------------------------------------------------
   def name(id)
     return if @file.nil?
     return split(@file[id])
   end
 end
 #==============================================================================
 # • TextBase
 #==============================================================================
 Dax.register(:text_base)
 class TextBase
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize
     @text = ""
   end
   #----------------------------------------------------------------------------
   # • Adicionar texto.
   #----------------------------------------------------------------------------
   def text=(text_add)
     @text += text_add
   end
   #----------------------------------------------------------------------------
   # • Adicionar uma nova linha.
   #----------------------------------------------------------------------------
   def text(text, nspace=0)
     @text += "\r\n" + (" " * nspace) + text
   end
   #----------------------------------------------------------------------------
   # • Adicionar comentário;
   #----------------------------------------------------------------------------
   def comment=(text_add, comment="#")
     @text += comment + text_add
   end
   #----------------------------------------------------------------------------
   # • Adicionar uma nova linha como comentário.
   #----------------------------------------------------------------------------
   def comment(text, nspace=0, comment="#")
     @text += "\r\n" + (" " * nspace) + comment + text
   end
   #----------------------------------------------------------------------------
   # • Salvar o texto.
   #----------------------------------------------------------------------------
   def save(filename="")
     _file = File.open(filename, "a+").each { |file|
       file.write(@text.to_s)
       file.close
     }
   end
 end
 #==============================================================================
 # • DRGSS | Comandos do RGSS...
 #==============================================================================
 Dax.register(:drgss)
 module DRGSS
   extend self
   #----------------------------------------------------------------------------
   # • **** Método ainda não explicado ****
   #----------------------------------------------------------------------------
   def recursive_delete(dir)
     files = []
     Dir.foreach(dir) do |fname|
       next if fname == '.' || fname == '..'
       path = dir + '/' + fname
       if File.directory?(path)
         puts "dir #{path}"
         recursive_delete(path)
       else
         puts "file #{path}"
         files << path
       end
     end
     files.each do |path|
       msgbox "delete file #{path}"
     end
     msgbox "delete dir #{dir}"
     Dir.rmdir(dir)
   end
   #----------------------------------------------------------------------------
   # • **** Método ainda não explicado ****
   #----------------------------------------------------------------------------
   def delete(directory)
     if File.directory?(directory)
       Dir.foreach(directory) do |file_or_directory|
             File.delete(directory+"/"+file_or_directory) if file_or_directory != "." and file_or_directory != ".."
       end
     else
       begin
         File.delete(directory) if File.new(directory).stat.size == 0
       rescue
         msgbox "#{$!} Error in deleting zero size file "
       end
     end
   end
   #----------------------------------------------------------------------------
   # • Extrair scripts do Database para um arquivo de extensão de texto.
   # options : Caso você deixe assim: {folder: "NM"}
   #  NM => Nome da pasta na qual os arquivos irão.
   #----------------------------------------------------------------------------
   def extract_scripts(type=".txt",options={})
     except = options[:except] || []
     folder = options[:folder] || ""
     id = 0 #
     $RGSS_SCRIPTS.each do |script|
       name = script[1]
       data = script[3]
       next if except.include? name or name.empty? or data.empty?
       filename = sprintf("%03d", id) + "_" + name
       p "Writing: #{filename}"
       File.open(folder+filename+"#{type}", "wb") do |file|
         file.write data
       end
       id += 1
     end
   end
   #----------------------------------------------------------------------------
   # • Guarda todos os scripts do Database num arquivo;
   #----------------------------------------------------------------------------
   def keep_scripts_in_file(filename="RGSS.rvdata2")
     unless FileTest.exist?(filename)
       self.extract_scripts(".txt")
       file = File.open(filename, "wb")
       Dir.glob("./*.{txt}").each_with_index { |v,i|
         next unless v.match(/(\d+){3}_(\w*)/)
         file.write(IO.readlines(v).to_s)
         File.delete(v)
       }
       file.close
     end
   end
   #----------------------------------------------------------------------------
   # • **** Método ainda não explicado ****
   #----------------------------------------------------------------------------
   def load_scripts(type=".txt",options={})
     skip = options[:skip] || []
     folder = options[:folder] || ""
     begin
       Dir.foreach(folder) do |file|
         file_id = file[0,3].to_i
         break if file_id == options[:limit]
         next if file == "." or file == ".." or File.extname(file) != "#{type}" or skip.include?(file_id)
         r = load(folder+"#{file}")
         p "Loaded: #{r}"
       end
     end
   end
 end
 #==============================================================================
 # • OutlineFillRect **** Método ainda não explicado ****
 #==============================================================================
 Dax.register(:outline_fill_rect)
 class OutlineFillRect < Sprite
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(object, max=2, color=ColorBasic[-1])
     super([object.width, object.height])
     @object = object
     self.x, self.y, self.z = object.x, object.y, object.z
     self.bitmap.fill_rect(0, 0, max, self.height, color)
     self.bitmap.fill_rect(self.width-max, 0, max, self.height, color)
     self.bitmap.fill_rect(0, 0, self.width, max, color)
     self.bitmap.fill_rect(0, self.height-max, self.width, max, color)
   end
   #----------------------------------------------------------------------------
   # • Renovação dos objetos.
   #----------------------------------------------------------------------------
   def dispose
     self.bitmap.dispose unless self.bitmap.disposed?
     super
   end
   #----------------------------------------------------------------------------
   # • Atualização das coordenadas.
   #----------------------------------------------------------------------------
   def update
     self.x, self.y, self.z = @object.x, @object.y, @object.z
   end
 end
 #==============================================================================
 # • Backup Complete
 #==============================================================================
 Dax.register(:backup)
 module Backup
   extend self
   # Criar as pastas.
   def make_past
     Dir.mkdir("Backup") unless File.directory?("Backup")
     ["Data", "System", "Movies", "Graphics", "Audio", "Audio/BGM", "Audio/BGS", "Audio/ME", "Audio/SE"].each { |i|
       Dir.mkdir("Backup/#{i}") unless File.directory?("Backup/#{i}")
     }
   end
   # Cópiar da pasta system.
   def system
     list = Dir.glob('System/*')
     list.size.times { |i|API.copyFile(list[i], "Backup/" + list[i], true.boolean)}
   end
   # Cópiar da pasta Movies.
   def movies
     movies = Dir.glob("Movies/*")
     movies.size.times { |i| API.copyFile(movies[i], "Backup/" + movies[i], true.boolean)}
   end
   # Cópiar da pasta Audio.
   def audio
     bgm = Dir.glob('Audio/BGM/*')
     bgs = Dir.glob('Audio/BGS/*')
     me = Dir.glob('Audio/ME/*')
     se = Dir.glob('Audio/SE/*')
     bgm.size.times { |i| API.copyFile(bgm[i], "Backup/" + bgm[i], true.boolean)}
     bgs.size.times { |i| API.copyFile(bgs[i], "Backup/" + bgs[i], true.boolean) }
     me.size.times { |i| API.copyFile(me[i], "Backup/" + me[i], true.boolean) }
     se.size.times { |i| API.copyFile(se[i], "Backup/" + se[i], true.boolean) }
   end
   # Cópiar da pasta Data
   def data
     data = Dir.glob('Data/*')
     data.size.times { |i| API.copyFile(data[i], "Backup/" + data[i], true.boolean) }
   end
   # Cópiar da pasta Graphics.
   def graphics
     ["Animations", "Battlebacks1", "Battlebacks2", "Battlers", "Characters",
      "Faces", "Parallaxes", "Pictures", "System", "Titles1", "Titles2",
      "Tilesets"].each { |dirs|
        Dir.mkdir("Backup/Graphics/#{dirs}") unless File.directory?("Backup/Graphics/#{dirs}")
        d = Dir.glob("Graphics/#{dirs}/*")
        d.size.times { |v| API.copyFile(d[v], "Backup/" + d[v], true.boolean) }
      }
   end
   # Executar
   def run(audios=false, graphic=false)
     return unless $TEST
     make_past
     movies
     data
     system
     audio if audios
     graphics if graphic
   end
 end
 #==============================================================================
 # * SceneManager
 #==============================================================================
 Dax.register :scenemanager
 Dax.required_class("SceneManager"){
 class  << SceneManager
   #----------------------------------------------------------------------------
   # • **** Método ainda não explicado ****
   #----------------------------------------------------------------------------
   def symbol(scene_symbol)
     eval("self.call(#{scene_symbol.to_s})")
   end
 end
 }
 #==============================================================================
 # • Sprite_Text
 #==============================================================================
 Dax.register(:sprite_text)
 class Sprite_Text < Sprite
   #----------------------------------------------------------------------------
   # • Variáveis públicas da instância.
   #----------------------------------------------------------------------------
   attr_accessor :text # Mudar de texto...
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(x, y, width, height, text, align=0)
     super([width, height])
     self.x, self.y = x, y
     @text = text
     self.bitmap.draw_text_rect(@text, align)
   end
   #----------------------------------------------------------------------------
   # • Renovação dos objetos.
   #----------------------------------------------------------------------------
   def dispose
     self.bitmap.dispose
     super
   end
   #----------------------------------------------------------------------------
   # • Atualização dos objetos.
   #----------------------------------------------------------------------------
   def update
     self.bitmap.clear
     super
     self.bitmap.draw_text_rect(@text)
   end
   def name=(value=nil)
     self.bitmap.font.name = name || Font.default_name.to_s
   end
   #----------------------------------------------------------------------------
   # • Negrito na fonte?
   #----------------------------------------------------------------------------
   def bold=(value=nil)
     self.bitmap.font.bold = value || true
   end
   #----------------------------------------------------------------------------
   # • Itálico na fonte?
   #----------------------------------------------------------------------------
   def italic=(value=nil)
     self.bitmap.font.italic = value || true
   end
   #----------------------------------------------------------------------------
   # • Sombra na fonte?
   #----------------------------------------------------------------------------
   def shadow=(value=nil)
     self.bitmap.font.shadow = value || true
   end
   #----------------------------------------------------------------------------
   # • Borda na fonte?
   #----------------------------------------------------------------------------
   def outline=(value=nil)
     self.bitmap.font.outline = value || true
   end
   #----------------------------------------------------------------------------
   # • Mudar a cor da fonte:
   #----------------------------------------------------------------------------
   def color=(color=nil)
     self.bitmap.font.color = color || -1.color
   end
   #----------------------------------------------------------------------------
   # • Mudar a cor da borda da fonte.
   #----------------------------------------------------------------------------
   def out_color=(out_color=nil)
     self.bitmap.font.out_color = out_color || 7.color
   end
 end
 #==============================================================================
 # • StringSprite : Permite digitar pelo teclado.
 #==============================================================================
 Dax.register :key_string_sprite
 class KeyStringSprite < Sprite_Text
   attr_reader :text
   #--------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #--------------------------------------------------------------------------
   def initialize(x, y, width, height, input="trigger?")
     super(x, y, width, height, "")
     @input = input
   end
   #--------------------------------------------------------------------------
   # • Renovação dos objetos.
   #--------------------------------------------------------------------------
   def dispose
     super
   end
   #--------------------------------------------------------------------------
   # • Atualização dos objetos.
   #--------------------------------------------------------------------------
   def update
     @text += Key.string(@input) unless Key.string(@input) == ""
     @text = DString.backslash(@text) if Key.trigger?(Key::BACKSPACE)
     super
   end
 end
 #==============================================================================
 # • Sprite_Icon
 #==============================================================================
 Dax.register(:sprite_icon)
 class Sprite_Icon < Sprite
   #----------------------------------------------------------------------------
   # • Variáveis públicas da instância.
   #----------------------------------------------------------------------------
   attr_accessor :icon_index # Mudar de ícone.
   attr_accessor :enabled # Tornar opaco ou não.
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(x, y, icon_index, enabled=true)
     super([24, 24])
     self.x, self.y = x, y
     @icon_index = icon_index.to_i
     @enabled = enabled
     self.bitmap.draw_icon(@icon_index, 0, 0, @enabled)
   end
   #----------------------------------------------------------------------------
   # • Renovação dos objetos.
   #----------------------------------------------------------------------------
   def dispose
     self.bitmap.dispose
     super
   end
   #----------------------------------------------------------------------------
   # • Atualização dos objetos.
   #----------------------------------------------------------------------------
   def update
     self.bitmap.clear
     super
     self.bitmap.draw_icon(@icon_index, 0, 0, @enabled)
   end
 end
 #==============================================================================
 # • Opacity
 #==============================================================================
 Dax.register(:opacity)
 module Opacity
   extend self
   @key ||= {}
   #----------------------------------------------------------------------------
   # • Efeito de opacidade que vai aumentando e diminuindo.
   # sprite : Objeto na qual sofrerá o efeito. [Sprite]
   # speed : Velocidade na qual o efeito irá acontencer.
   # max : Valor máximo na qual irá ser atingido.
   # min : Valor minímo na qual irá ser atingido.
   #----------------------------------------------------------------------------
   def sprite_opacity(sprite, speed, max, min, hash=nil)
     @key[hash.nil? ? hash.__id__ : hash] || false
     unless @key[hash]
       sprite.opacity += speed unless sprite.opacity >= max
       @key[hash] = sprite.opacity >= max
     else
       sprite.opacity -= speed unless sprite.opacity <= min
       @key[hash] = false if sprite.opacity <= min
     end
   end
   #----------------------------------------------------------------------------
   # • Efeito de opacidade por fora.
   # sprite : Objeto na qual sofrerá o efeito. [Sprite]
   # speed : Velocidade na qual o efeito irá acontencer.
   # max : Valor máximo na qual irá ser atingido.
   #----------------------------------------------------------------------------
   def sprite_opacity_out(sprite, speed, max)
     sprite.opacity += speed unless sprite.opacity >= max
   end
   #----------------------------------------------------------------------------
   # • Efeito de opacidade por dentro.
   # sprite : Objeto na qual sofrerá o efeito. [Sprite]
   # speed : Velocidade na qual o efeito irá acontencer.
   #  min : Valor minímo na qual irá ser atingido.
   #----------------------------------------------------------------------------
   def sprite_opacity_in(sprite, speed, min)
     sprite.opacity -= speed unless sprite.opacity <= min
   end
   #--------------------------------------------------------------------------
   # • Efeito de fade out em massa
   #     time : duração (em milesegundo)
   #--------------------------------------------------------------------------
   def fadeout_all(time = 1000)
     RPG::BGM.fade(time)
     RPG::BGS.fade(time)
     RPG::ME.fade(time)
     Graphics.fadeout(time * Graphics.frame_rate / 1000)
     RPG::BGM.stop
     RPG::BGS.stop
     RPG::ME.stop
   end
   #----------------------------------------------------------------------------
   # • Limpar variável.
   #----------------------------------------------------------------------------
   def clear
     @key.clear
   end
 end
 #==============================================================================
 # • Rpg
 #==============================================================================
 Dax.register(:rpg)
 module Rpg
   def self.data_manager
   end
   #============================================================================
   # • Hud
   #============================================================================
   module Hud
 
   end
   #============================================================================
   # • Menu
   #============================================================================
   module Menu
     extend self
     def include_item?(item)
       item.is_a?(RPG::Item) && !item.key_item?
     end
     #--------------------------------------------------------------------------
     # • *** Método aidna não explicado ****
     #--------------------------------------------------------------------------
     def cursor_up(variable, max)
       variable += 1 unless variable > max
       variable = 0 if variable > max
       return variable
     end
     #--------------------------------------------------------------------------
     # • *** Método aidna não explicado ****
     #--------------------------------------------------------------------------
     def cursor_down(variable, max)
       variable -= 1 unless variable < 0
       variable = max if variable < 0
       return variable
     end
   end
   #============================================================================
   # • Battle
   #============================================================================
   module Battle
   end
   #============================================================================
   # • Title
   #============================================================================
   module Title
   end
 end
 #==============================================================================
 # • String
 #==============================================================================
 Dax.register :shortcut
 class String
   #----------------------------------------------------------------------------
   # • *** Método aidna não explicado ****
   #----------------------------------------------------------------------------
   def script
     if self.match(/G: ([^>]*)/)
       return "Graphics/#{$1}"
     elsif self.match(/C:(\w+):([^>]*)/)
       case $1
       when "S"
         return Cache.system($2.to_s)
       when "P"
         return Cache.picture($2.to_s)
       when "Pl"
         return Cache.parallax($2.to_s)
       when "C"
         return Cache.character($2.to_s)
       when "A"
         return Cache.animation($2.to_s)
       when "B1"
         return Cache.battleback1($2.to_s)
       when "B2"
         return Cache.battleback2($2.to_s)
       when "B"
         return Cache.battler($2.to_s)
       when "F"
         return Cache.face($2.to_s)
       when "T1"
         return Cache.title1($2.to_s)
       when "T2"
         return Cache.title2($2.to_s)
       when "T"
         return Cache.tileset($2.to_s)
       end
     end
   end
 end
 #==============================================================================
 # • Txt
 #==============================================================================
 Dax.register(:read, "Dax")
 module Read
   extend self
   #----------------------------------------------------------------------------
   # • Verificar valor numérico após uma palavra em um arquivo.
   #----------------------------------------------------------------------------
   def numeric(file, tag)
     IO.readlines(file).each do |line|
       return $1.to_i if line.match(/#{tag} (\d+)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Verificar valor de uma palavra(string única) após uma palavra em um arquivo
   #----------------------------------------------------------------------------
   def string(file, tag)
     IO.readlines(file).each do |line|
       return $1.to_s if line.match(/#{tag} (\w+)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Verificar um conteúdo após uma palavra de um arquivo.
   #----------------------------------------------------------------------------
   def content(file, tag)
     IO.readlines(file).each do |line|
       return $1 if line.match(/#{tag} ([^>]*)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Multiplo número..
   #----------------------------------------------------------------------------
   def multiple_numeric(file, tag)
     IO.readlines(file).each do |line|
       return [$1.to_i, $2.to_i] if line.match(/#{tag} (\d+), (\d+)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Multiplo string..
   #----------------------------------------------------------------------------
   def multiple_string(file, tag)
     IO.readlines(file).each do |line|
       return [$1.to_s, $2.to_s] if line.match(/#{tag} (\w+), (\w+)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Triplo número.
   #----------------------------------------------------------------------------
   def triple_numeric(file, tag)
     IO.readlines(file).each do |line|
       return [$1.to_i, $2.to_i, $3.to_i] if line.match(/#{tag} (\d+), (\d+), (\d+)/)
     end
   end
   #----------------------------------------------------------------------------
   # • Triplo string.
   #----------------------------------------------------------------------------
   def triple_string(file, tag)
     IO.readlines(file).each do |line|
       return [$1.to_s, $2.to_s, $3.to_s] if line.match(/#{tag} (\w+), (\w+), (\w+)/)
     end
   end
   # true or false
   def of(file, tag)
     IO.readlines(file).each do |line|
       return $1.to_s == "true" ? true : false if line.match(/#{tag} ([^>]*)/)
     end
   end
 end
 
 #==============================================================================
 # • Background
 #==============================================================================
 Dax.register :background
 module Background
   extend self
   @background ||= {}
   #----------------------------------------------------------------------------
   # • Plano de fundo padrão...
   #----------------------------------------------------------------------------
   def default(alpha=128, key=nil)
     @background[key.__id__] = Sprite.new
     @background[key.__id__].bitmap = SceneManager.background_bitmap
     @background[key.__id__].color.set(16, 16, 16, alpha)
   end
   #----------------------------------------------------------------------------
   # • Plano de fundo padrão renovado.
   #----------------------------------------------------------------------------
   def default_dispose
     return if @background.nil?
     @background.each_value(&:dispose)
   end
   # Definir um sprite de fundo
   def define_back(color="ffffff".color, key=nil)
     @background[key.__id__] = Sprite.new([Graphics.width, Graphics.height])
     @background[key.__id__].bitmap.fill_rect(@background[key.__id__].rect, color)
   end
 end
 #==============================================================================
 # * Window_Base
 #==============================================================================
 Dax.register(:window_base)
 Dax.required_class("Window_Base") {
 class Window_Base < Window
   #----------------------------------------------------------------------------
   # • Slide pela direita.
   #   * speed : Velocidade | point : Ponto da coordenada X que irá chegar.
   #----------------------------------------------------------------------------
   def slide_right(speed, point)
     self.x += speed unless self.x >= point
   end
   #----------------------------------------------------------------------------
   # • Slide pela esquerda.
   #   * speed : Velocidade | point : Ponto da coordenada X que irá chegar.
   #----------------------------------------------------------------------------
   def slide_left(speed, point)
     self.x -= speed unless self.x <= point
   end
   #----------------------------------------------------------------------------
   # • Slide por cima.
   #   * speed : Velocidade | point : Ponto da coordenada Y que irá chegar.
   #----------------------------------------------------------------------------
   def slide_up(speed, point)
     self.y -= speed unless self.y <= point
   end
   #----------------------------------------------------------------------------
   # • Slide por baixo.
   #   * speed : Velocidade | point : Ponto da coordenada Y que irá chegar.
   #----------------------------------------------------------------------------
   def slide_down(speed, point)
     self.y += speed unless self.y >= point
   end
   #----------------------------------------------------------------------------
   # • Define aqui uma posição fixa para um objeto.
   #   command : Retorna a uma base padrão.
   #----------------------------------------------------------------------------
   def position(command=0)
     return if command.nil?
     case command
     # Imagem ficará no canto esquerdo superior. Posição X
     when 0 then self.x = 0
     # A posição X ficará no centro da tela.
     when 1 then self.x = DMath.get_x_center_screen(self.width)
     # A posição X ficará no canto direito superior.
     when 2 then self.x = Graphics.width - self.width
     # A posição Y ficará no canto esquerdo inferior.
     when 3 then self.y = 0
     # Posicionar o Y para ficar no centro.
     when 4 then self.y = DMath.get_y_center_screen(self.height)
     # Posicionar o Y para ficar no fundo da tela.
     when 5 then self.y = Graphics.height - self.height
     # Posicionar a imagem no centro da tela.
     when :center
       self.x = (Graphics.width - self.width) / 2
       self.y = Graphics.height / 2 - self.height / 2
     # Posicionar no centro esquerdo da tela.
     when :center_left
       self.x = 0
       self.y = (Graphics.height - self.height) / 2
     # Posicionar no centro direito da tela.
     when :center_right
       self.x = Graphics.width - self.height
       self.y = (Graphics.height - self.height) / 2
     end
   end
 end
 }
 #==============================================================================
 # • Map
 #==============================================================================
 Dax.register(:map)
 module Map
   extend self
   #----------------------------------------------------------------------------
   # • Mapeiar área.
   #     map : Objeto [SPRITE].. que será escaniado..
   #     scan_sprite : Objeto [SPRITE].. que irá projetar o scan.
   #     color : Cor do scan.
   #----------------------------------------------------------------------------
   def char_area(map, scan_sprite, color=ColorBasic[-1])
     _table = Table.new(map.width, map.height)
     for x in 0..._table.xsize
       for y in 0..._table.ysize
         next if map.bitmap.get_pixel(x, y).alpha == 0
         scan_sprite.bitmap.set_pixel(x, y, color)
       end
     end
   end
   #----------------------------------------------------------------------------
   # • Colidir com determinada cor de um objeto sprite.
   #    ar : [largura, altura, bloqueio da esquerda, bloqueio de cima]
   #    object : Objeto a colidir. [SPRITE]
   #    map : Mapa. [SPRITE]
   #    color : Cor, na qual quando o objeto colidir com está cor.. ativa.
   #---------------------------------------------------------------------------
   def collide_with_color(object, map, color, ar=[28,30,30,30])
     (ar[0]...object.width).each { |w| (ar[1]...object.height).each { |h|
      _r = map.bitmap.get_pixel(object.x+w, object.y+h) == color[:right]
      _l = map.bitmap.get_pixel(object.x+ar[2]-w, object.y+h) == color[:left]
      _d = map.bitmap.get_pixel(object.x+w, object.y+h) == color[:down]
      _u = map.bitmap.get_pixel(object.x+w, object.y+ar[3]-h) == color[:up]
      return {right: _r, left: _l, down: _d, up: _u}
     }}
   end
 end
 #==============================================================================
 # • VS | Variables & Switches
 #==============================================================================
 Dax.register(:vs)
 module VS
   #----------------------------------------------------------------------------
   # • Função do módulo.
   #----------------------------------------------------------------------------
   module_function
   #----------------------------------------------------------------------------
   # • Desligar a quantia predestinada de switches...
   #----------------------------------------------------------------------------
   def off_switche(value=9999)
     Dax.required_class("$game_switches"){value.times { |index| $game_switches[index] = false }
     $game_switches.on_change}
   end
   #----------------------------------------------------------------------------
   # • Ativar a quantia predestinada de switches...
   #----------------------------------------------------------------------------
   def on_switche(value=9999)
     Dax.required_class("$game_switches"){value.times { |index| $game_switches[index] = true }
     $game_switches.on_change}
   end
   #----------------------------------------------------------------------------
   # • Salvar as variáveis do jogo em um arquivo
   #    *args : IDs delas.. exemplo: 1, 2, 3, 4
   #----------------------------------------------------------------------------
   def save_game_variable(*args)
     Dax.required_class("$game_variables"){
     Dax.required_file("savedGameVariables.rvdata2"){File.delete("savedGameVariables.rvdata2")}
     i = [*args]
     sgv = [{}]
     (0...i.size-1).each { |index| sgv[0][index] = $game_variables[index] }
     save_data(sgv, "savedGameVariables.rvdata2")
     }
   end
   #----------------------------------------------------------------------------
   # • Carregar as variáveis do jogo dum arquivo
   #    *args : IDs delas.. exemplo: 1, 2, 3, 4
   #----------------------------------------------------------------------------
   def load_game_variable(*args)
     Dax.required_class("$game_variables"){
     Dax.required_file("savedGameVariables.rvdata2"){
     i = [*args]
     sgv = load_data("savedGameVariables.rvdata2")
     (0...i.size-1).each { |index| $game_variables[index] = sgv[0][index]}
 
     }}
   end
   #----------------------------------------------------------------------------
   # • Salvar as switches do jogo em um arquivo
   #    *args : IDs delas.. exemplo: 1, 2, 3, 4
   #----------------------------------------------------------------------------
   def save_switches_variable(*args)
     Dax.required_class("$game_switches"){
     Dax.required_file("savedGameSwitches.rvdata2"){File.delete("savedGameSwitches.rvdata2")}
     i = [*args]
     sgs= [{}]
     (0...i.size-1).each { |index| sgs[0][index] = $game_switches[index] }
     save_data(sgs, "savedGameSwitches.rvdata2")
     }
   end
   #----------------------------------------------------------------------------
   # • Carregar as variáveis do jogo dum arquivo
   #    *args : IDs delas.. exemplo: 1, 2, 3, 4
   #----------------------------------------------------------------------------
   def load_game_variable(*args)
     Dax.required_class("$game_switches"){
     Dax.required_file("savedGameSwitches.rvdata2"){
     i = [*args]
     sgs = load_data("savedGameSwitches.rvdata2")
     (0...i.size-1).each { |index| $game_switches[index] = sgs[0][index]}
 
     }}
   end
 end
 #==============================================================================
 # • Sound Base
 #==============================================================================
 Dax.register(:sound_base)
 module Sound_Base
   #----------------------------------------------------------------------------
   # • Função do módulo.
   #----------------------------------------------------------------------------
   module_function
   #----------------------------------------------------------------------------
   # • Executar um som.
   #----------------------------------------------------------------------------
   def play(name, volume, pitch, type = :se)
     case type
     when :se  ; RPG::SE.new(name, volume, pitch).play rescue valid?(name)
     when :me  ; RPG::ME.new(name, volume, pitch).play rescue valid?(name)
     when :bgm ; RPG::BGM.new(name, volume, pitch).play rescue valid?(name)
     when :bgs ; RPG::BGS.new(name, volume, pitch).play rescue valid?(name)
     end
   end
   #----------------------------------------------------------------------------
   # • Validar som.
   #----------------------------------------------------------------------------
   def valid?(name)
     raise("Arquivo de som não encontrado: #{name}")
     exit
   end
 end
 #==============================================================================
 # • Position.
 #==============================================================================
 Dax.register :position
 class Position
   #----------------------------------------------------------------------------
   # • Variáveis públicas da instância.
   #----------------------------------------------------------------------------
   attr_accessor :x  # Variável que retorna ao valor que indica a posição X.
   attr_accessor :y  # Variável que retorna ao valor que indica a posição Y.
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(x, y)
     @x = x || 0
     @y = y || 0
   end
   #----------------------------------------------------------------------------
   # • Somar com outra posição.
   #----------------------------------------------------------------------------
   def +(position)
     position = position.position unless position.is_a?(Position)
     Position.new(self.x + position.x, self.y + position.y)
   end
   #----------------------------------------------------------------------------
   # • Subtrair com outra posição.
   #----------------------------------------------------------------------------
   def -(position)
     position = position.position unless position.is_a?(Position)
     Position.new(self.x - position.x, self.y - position.y)
   end
   #----------------------------------------------------------------------------
   # • Multiplicar com outra posição.
   #----------------------------------------------------------------------------
   def *(position)
     position = position.position unless position.is_a?(Position)
     Position.new(self.x * position.x, self.y * position.y)
   end
   #----------------------------------------------------------------------------
   # • Dividir com outra posição.
   #----------------------------------------------------------------------------
   def /(position)
     position = position.position unless position.is_a?(Position)
     return if (self.x or position.x or self.y or position.y) <= 0
     Position.new(self.x / position.x, self.y / position.y)
   end
   #----------------------------------------------------------------------------
   # • Comparar com outra posição.
   #----------------------------------------------------------------------------
   def ==(position)
     position = position.position unless position.is_a?(Position)
     return self.x == position.x && self.y == position.y
   end
   #----------------------------------------------------------------------------
   # • Converter em string.
   #----------------------------------------------------------------------------
   def to_s
     return "position x: #{self.x}\nposition y: #{self.y}"
   end
 end
 #==============================================================================
 # • Vector
 #==============================================================================
 Dax.register(:vector)
 class Vector
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos. x, y, w, h
   #----------------------------------------------------------------------------
   def initialize(*args)
     @vector = *args
   end
   #----------------------------------------------------------------------------
   # • Rotacionar
   #----------------------------------------------------------------------------
   def rotate(angle)
     x = @vector[0] * Math.cos(Math::PI / 180 * angle) - @vector[1] * Math.sin(Math::PI / 180 * angle)
     y = @vector[0] * Math.sin(Math::PI / 180 * angle) + @vector[1] * Math.cos(Math::PI / 180 * angle)
     temp = @vector.dup
     temp[0], temp[1] = x, y
     return Vector.new(*temp)
   end
   #----------------------------------------------------------------------------
   # • Somar com outra classe Vector
   #----------------------------------------------------------------------------
   def +(v)
     return Vector.new(*@vector.map.each_index{|s,i| s + v[i]}) if v.is_a?(Vector)
     return Vector.new(*@vector.map.each_index{|s,i| s + v[i]}) if v.is_a?(Array)
     return Vector.new(*@vector.map{|s| + v}) if v.is_a?(Numeric)
     return nil
   end
   #----------------------------------------------------------------------------
   # • Multiplicar com Matrix.
   #----------------------------------------------------------------------------
   def *(matrix)
     result = []
     for i in 0..(matrix.size-1)
       data = 0
       for j in 0..(@vector.size-1)
         data += @vector[j] * matrix[j][i]
       end
       result.push(data)
     end
     return Vector.new(*result)
   end
   #----------------------------------------------------------------------------
   # • Arr.
   #----------------------------------------------------------------------------
   def [](index)
     return @vector[index]
   end
   #----------------------------------------------------------------------------
   # • Tamanho.
   #----------------------------------------------------------------------------
   def size
     @vector.size
   end
   #----------------------------------------------------------------------------
   # • Converter para array.
   #----------------------------------------------------------------------------
   def to_a
     @vector
   end
   # x
   def x; return @vector[0]; end;
   # Y
   def y; return @vector[1]; end;
   # z
   def z; return @vector[2]; end;
   # w
   def w; return @vector[3]; end;
 end
 #==============================================================================
 # • Matrix
 #==============================================================================
 Dax.register(:matrix)
 class Matrix
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos.
   #----------------------------------------------------------------------------
   def initialize(*args)
     @arr = Array.new(4) { |i| Vector.new(*args[i]) }
   end
   #----------------------------------------------------------------------------
   # • Multiplicar.
   #----------------------------------------------------------------------------
   def *(a)
     result = []
     for i in 0..(a.size-1)
       result.push(@arr[i] * a)
     end
     return Matrix.new(*result)
   end
   #----------------------------------------------------------------------------
   # • []
   #----------------------------------------------------------------------------
   def [](index)
     return @arr[index]
   end
   #----------------------------------------------------------------------------
   # • Tamanho
   #----------------------------------------------------------------------------
   def size
     return @arr.size
   end
   #----------------------------------------------------------------------------
   # • Criar rotação em z.
   #----------------------------------------------------------------------------
   def self.create_rotation_z(angle)
     cos = Math.cos(Math::PI/180 * angle)
     sin = Math.sin(Math::PI/180 * angle)
     return Matrix.new(
      [ cos, sin, 0, 0],
      [-sin, cos, 0, 0],
      [   0,   0, 1, 0],
      [   0,   0, 0, 1]
     )
   end
   #----------------------------------------------------------------------------
   # • Rotação em X
   #----------------------------------------------------------------------------
   def self.create_rotation_x(angle)
     cos = Math.cos(Math::PI/180 * angle)
     sin = Math.sin(Math::PI/180 * angle)
     return Matrix.new(
      [   1,   0,   0, 0],
      [   0, cos, sin, 0],
      [   0,-sin, cos, 0],
      [   0,   0,   0, 1]
     )
   end
   #----------------------------------------------------------------------------
   # • Rotação em Y
   #----------------------------------------------------------------------------
   def self.create_rotation_y(angle)
     cos = Math.cos(Math::PI/180 * angle)
     sin = Math.sin(Math::PI/180 * angle)
     return Matrix.new(
      [ cos,   0,-sin, 0],
      [   0,   1,   0, 0],
      [ sin,   0, cos, 0],
      [   0,   0,   0, 1]
     )
   end
   #----------------------------------------------------------------------------
   # • Transição.
   #----------------------------------------------------------------------------
   def self.create_transration(x, y, z)
     return Matrix.new(
      [   1,   0,   0,   0],
      [   0,   1,   0,   0],
      [   0,   0,   1,   0],
      [   x,   y,   z,   1]
     )
   end
   #----------------------------------------------------------------------------
   # • Para array
   #----------------------------------------------------------------------------
   def to_a
     @arr.map {|v|v.to_a}.flatten
   end
 end
 #==============================================================================
 # • Animation
 #==============================================================================
 Dax.register :animation
 class Animation
   attr_reader :size, :frame_size, :index, :max_width, :max_height
   #----------------------------------------------------------------------------
   # • Inicialização.
   #----------------------------------------------------------------------------
   def initialize(size, frame_size, wait=1)
     @size = size
     @frame_size = frame_size
     @index = 0
     @max_width = @size[0] / @frame_size[0]
     @max_height = @size[1] / @frame_size[1]
     @wait = wait
     @time = 0
   end
   #----------------------------------------------------------------------------
   # • Animação na horizontal.
   #----------------------------------------------------------------------------
   def horz
     @time += 1 unless @time >= @wait
     if @time >= @wait
       @index = Rpg::Menu.cursor_up(@index, @max_width)
       @time = 0
     end
   end
   #----------------------------------------------------------------------------
   # • Animação na vertical.
   #----------------------------------------------------------------------------
   def vert
     @time += 1 unless @time >= @wait
     if @time >= @wait
       @index = Rpg::Menu.cursor_up(@index, @max_height)
       @time = 0
     end
   end
 end
 #==============================================================================
 # • Sprite_Anime_Horz
 #==============================================================================
 Dax.register :sprite_anime_horz
 class Sprite_Anime_Horz < Sprite
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos
   #    filename : Nome do arquivo.
   #    frame_size : Tamanho de cada frame.
   #    wait : Tempo de espera para mudar de um frame para outro.
   #----------------------------------------------------------------------------
   def initialize(filename, frame_size, wait=1)
     @bitmap = Bitmap.new(filename)
     super(frame_size)
     @animation = Animation.new([@bitmap.width, @bitmap.height],
     frame_size, wait)
   end
   #----------------------------------------------------------------------------
   # • Renovação dos objetos.
   #----------------------------------------------------------------------------
   def dispose
     self.bitmap.dispose
     super
   end
   #----------------------------------------------------------------------------
   # • Atualização dos objetos.
   #----------------------------------------------------------------------------
   def update
     self.bitmap.clear
     super
     @animation.horz
     rect = Rect.new(@animation.index % @animation.max_width * @animation.frame_size[0],
     0, *@animation.frame_size)
     self.bitmap.blt(0, 0, @bitmap, rect)
   end
 end
 #==============================================================================
 # • Sprite_Anime_Vert
 #==============================================================================
 Dax.register :sprite_anime_vert
 class Sprite_Anime_Vert < Sprite
   #----------------------------------------------------------------------------
   # • Inicialização dos objetos
   #    filename : Nome do arquivo.
   #    frame_size : Tamanho de cada frame.
   #    wait : Tempo de espera para mudar de um frame para outro.
   #----------------------------------------------------------------------------
-# • Vibrator
+
     @bitmap = Bitmap.new(filename)
-Dax.register :vibrator
+
-module Vibrator
+
     frame_size, wait)
   end
-  # • Variáveis.
+
   # • Renovação dos objetos.
-  @vibrator ||= []
+
   def dispose
-  # • Adicionar um objeto a ser vibrado
+
     super
-  def add(x,y,z,filename,blend=0)
+
-    @vibrator << Sprite_Vibrator.new(x,y,z,filename,[0.1*(-25+rand(50))/10, 0], [0,0.13], [255,3],blend)
+
   # • Atualização dos objetos.
   #----------------------------------------------------------------------------
-  # • Atualizar as vibrações.
+
     self.bitmap.clear
     super
-    return if @vibrator.nil?
+
-    @vibrator.each_with_index { |particle, index|
+
-      next if particle.nil?
+
-      particle.update
+
-      unless particle.opacity > 0
+
-        particle.dispose
+
-        @vibrator.delete_at(index)
+
 # • Desativar scripts : Para fazer, basta por no nome do script da lista,
 # [D].
 #==============================================================================
 Dax.register(:disable_script)
-  # • Deletar as vibrações
+
  $RGSS_SCRIPTS.at(index)[2] = $RGSS_SCRIPTS.at(index)[3] = "" if data.at(1).include?("[D]")
-  def delete
+
-    @vibrator.each { |particle| particle.dispose unless particle.nil? and particle.disposed? }
+
-    @vibrator = []
+
 #==============================================================================
 Dax.register :cache
 Dax.required_class("Cache") {
-# • Sprite_Vibrator
+
   #----------------------------------------------------------------------------
-Dax.register :sprite_vibrator
+
-class Sprite_Vibrator < Sprite
+
   attr_accessor :cache # Variável cache.
 end
 }
-  def initialize(x, y, z, filename, acceleration, gravity, opacity, blend)
+
-    super(filename)
+
-    self.x, self.y, self.z = x, y, z
+
-    @acceleration = acceleration
+
-    @gravity = gravity
+
-    @opacity = opacity[1]
+
-    self.blend_type = blend
+
-    @original_position = [self.x, self.y]
+
-    self.opacity = opacity[0]
+
-    @coordinates = [0.00, 0.00]
+
       Rpg.data_manager
       Mouse.start
       new_init
     end
   end
 end
 #==============================================================================
 # * Input
 #==============================================================================
 class << Input
   alias :upft :update
   def update
     upft
     Key.update
-    1.times { |i|
+
-      @acceleration[i] -= @gravity[i] unless @gravity[i] == 0
+
-      @coordinates[i] += @acceleration[i]
+
 # • Graphics
-    self.opacity -= @opacity
+
-    self.x, self.y = @original_position[0] + @coordinates[0], @original_position[1] + @coordinates[1]
+
   alias :uptf :update
   def update
     uptf
     Mouse.update
   end
 end
 __END__
 :regexp_symbol
 #==============================================================================
 # • Regexp Symbol
 #==============================================================================
 
 Símbolos:
 
 [x]|[abc] : Um único caractér de: a, b ou c
 [^x]|[^abc] : Qualquer caractér exceto: a, b, ou c
 [a-z] : Um único caractér no intervalo de a...z
 [a-zA-Z] : Um único caractér no intervalo de a...z ou A...Z
 ^ : Começo da linha.
 $ : Fim da linha.
 \A : Começo da string.
 \z : Fim da string.
 . : Um único caractér
 \s : Qualquer carácter com espaço
 \S : Qualquer carácter sem espaço
 \d : Qualquer dígito
 \D : Qualquer um que não seja um dígito
 \w : Qualquer palavra
 \W : Qualquer um que não seja uma palavra.
 \b : Qualquer limite de palavra.
 (...) : Capturar tudo fechado.
 (x|y)|(a|b) : A(X) ou B(Y)
 x? : Zero ou um de x.
 x* : Zero ou mais de x.
 x+ : Um ou mais de x.
 x{3} : Exatamente 3 de x.
 x{3,} : Exatamente 3 ou mais de um de x.
 x{3,6} : Entre 3 e 6 de x.
 
 Opções:
 
 /i : Sem case sensitive
 /m : Para mais de uma linha
 /x : Ingnorar espaços brancos
 /o : Executar o #{...}, alterações apenas uma vez.
 
 /<tagName>(.*?)<\/tagName>/im
 
 <tagName>
 type: skill
 id: 2
 forced: true
 </tagName>
 
  ==============================================================================
 **** Método : 'if_mouse_over'
  O que esse método trata? Trata-se de que quando o Mouse estiver por cima de
 determinado objeto.. algo irá acontecer.
  Como eu configuro a ação que irá ocorrer caso o Mouse esteja por cima de
 determinado objeto?
  Bom, o método só irá funcionar com objetos que são da classe [Sprite], e ele
 retorna a um bloco(somente se definir)! Exemplo:
  sprite.if_mouse_over # Chamou o método.. Mais agora para definir o bloco basta
 usar as {chaves} e dentro da chave o bloco que irá ser executado. Ex:
  sprite.if_mouse_over {
   Comando que irá se executar caso o Mouse esteja por cima do determinado objeto.
  }
  Certo, mais agora como faço uma condição para fazer uma ação de que.. Se
 o Mouse esteja por cima de determinado objeto acontece algo, e quando ele não
 estiver ele executa outra coisa?
  Simples basta chamar a variável 'over', como chamar? Após o '{' usa-se
 |over| .. Essa variável retorna caso o Mouse esteja por cima ou não de um objeto
 com os valores true or false.. Um exemplo abaixo.
  sprite.if_mouse_over { |over|
   sprite.opacity = over ? 255 : 128
  }
  # O Exemplo acima.. Quando o Mouse estiver por cima.. a opacidade ficará com o
 valor de '255'.. e quando não estiver ficará em '128'.
  ==============================================================================
 *** Método : 'if_mouse_click'
  O que esse método trata? Trata-se de que quando o Mouse estiver por cima de
 determinado objeto e a clicar nele(com o botão direito/esquerdo). algo irá acontecer
  Como eu configuro a ação que irá ocorrer caso o Mouse esteja por cima de
 determinado objeto ao ser clicado? O mesmo método do de cima.
  Bom, o método só irá funcionar com objetos que são da classe [Sprite], e ele
 retorna a um bloco(somente se definir)! Exemplo:
  sprite.if_mouse_click(button) {
   Comando que irá se executar caso o sprite seja clicado com o Mouse.
  }
  * button * O button naturalmente e o botão esquerdo.. Então se quiser não
 precisa o configurar.. Mais caso queira olhe abaixo os valores a por em ()
  button : Button : (:right - botão direito do mouse | :left - botão esq.)
  Um Exemplo abaixo :
  sprite.if_mouse_click { msgbox("Você clicou em mim!") }