#==============================================================================
# Vampyr Message Balloon [VX]
#------------------------------------------------------------------------------
# Exibe as mensagens em forma de balão.
#------------------------------------------------------------------------------
# Autor                      : Vampyr
# Tradução PT e Modificações : Kyo Panda (http://www.mundorpgmaker.com.br/)
#==============================================================================

#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# • Muda a exibição das mensagens para balões.
# • Adiciona alguns códigos de mensagem extra.
# • Retira a face das mensagens.
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação
# #--------------------------------------------------------------------------
#
# • Cole o script acima do "▼ Principal" e abaixo dos "▼ Scripts Adicionais"
#   no Editor de Scripts do RPG Maker VX.
#
# • Configure o script no guia "Configuração" logo abaixo se desejar.
#
# #--------------------------------------------------------------------------
# # Utilização
# #--------------------------------------------------------------------------
#
# • Utilize os seguintes códigos na mensagem. Os códigos padrões do RPG Maker
#   VX também funcionam aqui.
#
#   \@[X]  = Onde X é a velocidade com que o texto é exibido.
#   \EV[X] = Exibe a mensagem sobre o evento de ID X.
#   \I[X]  = Exibe o ícone e o nome do item de ID X.
#   \W[X]  = Exibe o ícone e o nome da arma de ID X.
#   \A[X]  = Exibe o ícone e o nome da armadura de ID X.
#   \S[X]  = Exibe o ícone e o nome da habilidade de ID X.
#   \FN[X] = Muda a fonte para a fonte X.
#   \FS[X] = Muda o tamanho da fonte para X.
#   \FB    = Ativa o modo negrito da fonte.
#   \FI    = Ativa o modo itálico da fonte
#   \EN[X] = Exibe o nome do inimigo de ID X.
#   \CL[X] = Exibe o nome da classe de ID X.
#   \Map   = Exibe o nome do mapa atual.
#
#==============================================================================

#==============================================================================
# VMB_Options
#------------------------------------------------------------------------------
# Módulo que armazena as configurações para o script Vampyr Message Balloon.
#==============================================================================

module VMB_Options
  #--------------------------------------------------------------------------
  # Configurações
  #--------------------------------------------------------------------------

  # Defina aqui o nome padrão da fonte.
  FONT_NAME   = Font.default_name

  # Defina aqui o tamanho padrão da fonte.
  FONT_SIZE   = 16

  # Defina aqui se utilizará o sombremento da fonte.
  # Defina true para sim e false para não.
  FONT_SHADOW = false

  # Defina aqui  cor padrão da fonte.
  # Defina como Color.new(R, G, B, Opacidade)
  FONT_COLOR  = Color.new(255, 255, 255, 255) # Color.new(0, 0, 0, 255)

  # Defina aqui o SE tocado quando as letras da mensagem aparecem.
  # Defina como "" para não utilizar esta função.
  TYPE_SE     = ""

  #--------------------------------------------------------------------------
  # Fim da configuração
  #--------------------------------------------------------------------------
end

#==============================================================================
# Object
#------------------------------------------------------------------------------
# Classe de dados do Ruby.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# * Novo método: getw.
#==============================================================================

class Object
  #--------------------------------------------------------------------------
  # Retorna o tamanho de uma string
  #--------------------------------------------------------------------------
  def getw
    # Define um bitmap
    bitmap = Bitmap.new(1, 1)
    # Define o tamanho do texto
    size = bitmap.text_size(self.to_s).width
    # Faz o dispose do bitmap
    bitmap.dispose
    # Retorna o tamanho
    return size
  end
end

#==============================================================================
# Sprite_MessageBalloon
#------------------------------------------------------------------------------
# Sprite que exibe as mensagens do jogo em forma de balão.
#==============================================================================

class Sprite_MessageBalloon < Sprite
  #--------------------------------------------------------------------------
  # Inclusão das constantes e métodos do módulo VMB_Options
  #--------------------------------------------------------------------------
  include VMB_Options
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super()       # Chama os parâmetros da super classe
    self.z = 999  # Define a prioridade da mensagem
    reset         # Reinicia a janela
  end
  #--------------------------------------------------------------------------
  # Configuração da cor da letra
  #     n : cor da letra (0～31)
  #--------------------------------------------------------------------------
  def text_color(n)
    x = 64 + (n % 8) * 8
    y = 96 + (n / 8) * 8
    return Cache.system("Window").get_pixel(x, y)
  end
  #--------------------------------------------------------------------------
  # Reinicialização da mensagem
  #--------------------------------------------------------------------------
  def reset
    self.visible = false  # Definição da sua visibilidade
    @contents_x = 4       # Definição do alinhamento X do conteúdo da mensagem
    @contents_y = 4       # Definição do alinhamento Y do conteúdo da mensagem
    @wait_count = 0       # Contagem de espera
    @text_speed = 3       # Velocidade do texto
    @text = ""            # Texto à ser exibido
    @width = []           # Largura da janela
    @show_fast = false    # Mostrar rápido?
    @wait_input = false   # Aguardar comando?
    @closing = false      # Flag do fechamento da mensagem
    @terminate_message = false  # Flag da finalização da mensagem
    self.bitmap.dispose if self.bitmap != nil  # Dispose do conteúdo da mensagem
    self.bitmap = nil     # Definição do bitmap da mensagem
  end
  #--------------------------------------------------------------------------
  # Abrir mensagem
  #--------------------------------------------------------------------------
  def open
    # Define @character como o personagem
    @character = $game_player
    # Para cada i de 0 ao tamanho da mensagem
    for i in 0...$game_message.texts.size
      # O texto passa à ser um clone de i mais "\x00"
      @text += $game_message.texts[i].clone + "\x00"
    end
    # Converte os caracteres especiais
    convert_special_characters
    # Para cada i do texto, dividi-se à cada "\x00"
    for i in @text.split("\x00")
      # A largura passa a ser o tamanho do texto
      @width << @text[i].getw
    end
    # Define-se a altura da mensagem
    height = $game_message.texts.size * FONT_SIZE + (FONT_SIZE + 8)
    # Define-se o bitmap da mensagem
    self.bitmap = Bitmap.new(@width.max + 8, height)
    # Define-se o nome da fonte
    self.bitmap.font.name = FONT_NAME
    # Define-se o tamanho da fonte
    self.bitmap.font.size = FONT_SIZE
    # Define-se se a fonte terá sombreamento
    self.bitmap.font.shadow = FONT_SHADOW
    # Define-se a cor da fonte
    self.bitmap.font.color = FONT_COLOR
    # Define o compensamento horizontal do bitmap
    self.ox = self.bitmap.width / 2
    # Define o compensamento vertical do bitmap
    self.oy = self.bitmap.height / 2
    # Define-se um Rect de acordo com a largura e altura do bitmap
    rect = self.bitmap.rect.clone
    # Reduz-se a altura do bitmap em 16 pixels
    rect.height -= 16
    # Cria-se a ponta do balão da mensagem de acordo com seu posicionamento
    # Se for "Acima"
    if $game_message.position >= 2
      self.bitmap.fill_rect(self.ox - 4, 0, 1, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 1, 2, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 2, 3, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 3, 4, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 4, 5, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 5, 6, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 6, 7, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, 7, 8, 1, Color.new(255, 255, 255, 192))
      rect.y += 8
      @contents_y += 8
    # Se não for "Acima"
    else
      self.bitmap.fill_rect(self.ox - 4, rect.height + 0, 8, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 1, 7, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 2, 6, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 3, 5, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 4, 4, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 5, 3, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 6, 2, 1, Color.new(255, 255, 255, 192))
      self.bitmap.fill_rect(self.ox - 4, rect.height + 7, 1, 1, Color.new(255, 255, 255, 192))
    end
    # Preenche o bitmap do balão
    self.bitmap.fill_rect(rect, Color.new(255, 255, 255, 192))
    # Define-se a opacidade do balão
    self.opacity = 255
    # Define-se a visibilidade do balão
    self.visible = true
    # Define a mensagem como visivel
    $game_message.visible = true
  end
  #--------------------------------------------------------------------------
  # Fechar mensagem
  #--------------------------------------------------------------------------
  def close
    # Reinicia a mensagem
    reset
    # Inicia o processo principal da mensagem
    $game_message.main_proc.call if $game_message.main_proc != nil
    # Limpa a mensagem
    $game_message.clear
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    # Chama as propriedade da super classe
    super
    # Retorna se não houver texto
    return if $game_message.texts.empty?
    # Se a contegem de espera for mais que 0
    if @wait_count > 0
      # Reduz-se a contagem de espera em 1
      @wait_count -= 1
    # Se a mensagem estiver terminando
    elsif @terminate_message
      # Se a opacidade da mensagem for maior que 0
      if self.opacity > 0
        # Reduz-se a opacidade em 10.
        self.opacity -= 10
      # Se não
      else
        # Fecha a mensagem
        close
      end
      # Define a mensagem como invisível
      $game_message.visible = false
    # Se a mensagem estiver fechando
    elsif @closing
      # Se pressionar C ou B
      if Input.trigger?(Input::C) or Input.trigger?(Input::B)
        # Marca a mensagem como finalizando
        @terminate_message = true
      end
    # Se estiver aguardando por pressionamento
    elsif @wait_input
      # Se pressionar C ou B
      if Input.trigger?(Input::C) or Input.trigger?(Input::B)
        # Define a espera por pressionamento como falso
        @wait_input = false
      end
    # Se pressionar C
    elsif Input.trigger?(Input::C)
      # Marca como exibir rápido
      @show_fast = true
    # Se o texto for diferente de nulo
    elsif @text != ""
      # Atualiza a mensagem
      update_message
    # Se o texto for nulo
    elsif @text == ""
      # Abre a mensagem
      open
    end
    # Retorna se estiver visivel
    return unless self.visible
    # Define X como o posicionamento de @character
    self.x = @character.screen_x
    # Se estiver exibindo acima
    if $game_message.position >= 2
      # Define o posicionamento de acordo
      self.y = @character.screen_y + (self.bitmap.height / 2) + 8
    # Se não
    else
      # Define o posicionamento de acordo
      self.y = @character.screen_y - self.bitmap.height - 8
    end
  end
  #--------------------------------------------------------------------------
  # Conversão dos caracteres especiais
  #--------------------------------------------------------------------------
  def convert_special_characters
    # Tag de exibição da variável
    @text.gsub!(/\\V\[([0-9]+)\]/i) {$game_variables[$1.to_i]}
    # Tag da exibição do nome do personagem
    @text.gsub!(/\\N\[(\d+)\]/i)    {$game_actors[$1.to_i].name}
    # Tag da cor da fonte mensagem
    @text.gsub!(/\\C\[(\d+)\]/i)    {"\x01[#{$1}]"}
    # Tag da pausa da mensagem
    @text.gsub!(/\\\./)             {"\x03"}
    # Tag da pausa prolongada da mensagem
    @text.gsub!(/\\\|/)             {"\x04"}
    # Tag da espera de pressionamento pelo usuário
    @text.gsub!(/\\!/)              {"\x05"}
    # Tag da exibição da mensagem de uma vez
    @text.gsub!(/\\>/)              {"\x06"}
    # Tag do cancelamento da exibição da mensagem de uma vez
    @text.gsub!(/\\</)              {"\x07"}
    # Tag do fechamento automático da mensagem
    @text.gsub!(/\\\^/)             {"\x08"}
    # Tag da velocidade da mensagem
    @text.gsub!(/\\@\[(\d+)\]/i)    {@text_speed = $1.to_i; ""}
    # Tag do posicionamento da mensagem no evento
    @text.gsub!(/\\EV\[(\d+)\]/i)   {@character = $game_map.events[$1.to_i]; ""}
    # Tag da exibição do ícone e nome dos itens
    @text.gsub!(/\\I\[(\d+)\]/i)    {"\x10[#{$data_items[$1.to_i].icon_index}]#{$data_items[$1.to_i].name}"}
    # Tag da exibição do ícone e nome das armas
    @text.gsub!(/\\W\[(\d+)\]/i)    {"\x10[#{$data_weapons[$1.to_i].icon_index}]#{$data_weapons[$1.to_i].name}"}
    # Tag da exibição do ícone e nome das armaduras
    @text.gsub!(/\\A\[(\d+)\]/i)    {"\x10[#{$data_armors[$1.to_i].icon_index}]#{$data_armors[$1.to_i].name}"}
    # Tag da exibição do ícone e nome das habilidades
    @text.gsub!(/\\S\[(\d+)\]/i)    {"\x10[#{$data_skills[$1.to_i].icon_index}]#{$data_skills[$1.to_i].name}"}
    # Tag da mudança da fonte da mensagem
    @text.gsub!(/\\FN\[(.*?)\]/i)   {"\x10[#{$1}]"}
    # Tag da mudança do tamanho da fonte da mensagem
    @text.gsub!(/\\FS\[(.*?)\]/i)   {"\x12[#{$1}]"}
    # Tag do estilo negrito da fonte
    @text.gsub!(/\\FB/i)            {"\x13[#{$1}]"}
    # Tag do estilo itálico da fonte
    @text.gsub!(/\\FI/i)            {"\x14[#{$1}]"}
    # Tag da exibição do nome do inimigo
    @text.gsub!(/\\EN\[(\d+)\]/i)   {$data_enemies[$1.to_i].name}
    # Tag da exibição do nome da classe
    @text.gsub!(/\\CL\[(\d+)\]/i)   {$data_classes[$1.to_i].name}
    # Tag da exibição do nome do mapa
    @text.gsub!(/\\Map/i)           {$game_map.map_name}
    # Tag da exibição do caractere \
    @text.gsub!(/\\\\/)             {"\\"}
  end
  #--------------------------------------------------------------------------
  # Atualização da mensagem
  #--------------------------------------------------------------------------
  def update_message
    # Retorna se não houver bitmap
    return if self.bitmap == nil
    # Retorna se o bitmap foi disposed
    return if self.bitmap.disposed?
    # Realização do loop
    loop do
      # Define c como a divisão da mensagem em /
      c = @text.slice!(/./m)
      # Caso c
      case c
      # Se for nulo
      when nil
        # Define a contagem de espera como 10
        @wait_count = 10
        # Marca a mensagem como fechando
        @closing = true
        # Quebra o loop
        break
      # Se for normal
      when "\x00"
        # Define o alinhamento X do conteúdo como 4
        @contents_x = 4
        # Aumenta o alinhamento Y do conteúdo para mais o tamanho da fonte
        @contents_y += FONT_SIZE
        # Define como mostrar a mensagem rápido como falso
        @line_show_fast = false
        # Se não houver texto
        if @text.empty?
          # Define a contagem de espera como 10
          @wait_count = 10
          # Marca a mensagem como fechando
          @closing = true
          # Quebra o loop
          break
        end
      # Se for mudança de cor
      when "\x01"
        # Adquire o número do texto
        @text.sub!(/\[([0-9]+)\]/, "")
        # Define a cor da mensagem
        self.bitmap.font.color = text_color($1.to_i)
        # Prossegue com o loop
        next
      # Se esperar por 1/4 de segundo
      when "\x03"
        # Defina a espera como 15
        @wait_count = 15
        # Quebra o loop
        break
      # Se esperar por 1 segundo
      when "\x04"
        # Define a espera como 60
        @wait_count = 60
        # Quebra o loop
        break
      # Se aguardar pelo pressionamento do usuário
      when "\x05"
        # Marca a espera por pressionamento como verdadeiro
        @wait_input = true
        # Quebra o loop
        break
      # Quando mostrar rápido
      when "\x06"
        # Marca o mostrar rápido como verdadeiro
        @line_show_fast = true
      # Quando não mostrar rápido
      when "\x07"
        # Marca o mostrar rápido como falso
        @line_show_fast = false
      # Quando fechar a mensagem automaticamente
      when "\x08"
        # Marca o fechando como verdadeiro
        @closing = true
        # Marca a tag de fechamento como verdadeiro
        @terminate_message = true
        # Quebra o loop
        break
      # Definição do desenho do nome e ícone de um objeto
      when "\x10"
        # Adquire o index da string
        @text.sub!(/\[(\d+)\]/, "")
        # Desenha o ícone
        draw_icon($1.to_i, @contents_x, @contents_y)
        # Aumente o X do conteúdo em 26 devido ao ícone
        @contents_x += 26
      # Se mudar o nome da fonte
      when "\x11"
        # Adquire o nome da fonte da string
        @text.sub!(/\[(.*?)\]/, "")
        # Define o nome da fonte
        self.bitmap.font.name = ($1.to_s != "" ? $1.to_s : FONT_NAME)
      # Se mudar o tamanho da fonte
      when "\x12"
        # Adquire o tamanho da fonte da string
        @text.sub!(/\[(.*?)\]/, "")
        # Define o tamanho da fonte
        self.bitmap.font.size = ($1.to_i > 0 ? $1.to_i : FONT_SIZE)
      # Se definir o estilo da fonte para negrito
      when "\x13"
        # Adquire a tag da string
        @text.sub!(/\[(.*?)\]/, "")
        # Define a fonte como negrito
        self.bitmap.font.bold = !self.bitmap.font.bold
      # Se definir o estilo da fonte para itálico
      when "\x14"
        # Adquire a tag da string
        @text.sub!(/\[(.*?)\]/, "")
        # Define a fonte como itálico
        self.bitmap.font.italic = !self.bitmap.font.italic
      # Se não
      else
        # Desenha o texto
        self.bitmap.draw_text(@contents_x, @contents_y, 20, FONT_SIZE, c)
        # Aumenta o alinhamento x
        @contents_x += c.getw
        # Reproduz o SE da mensagem
        RPG::SE.new(TYPE_SE).play if TYPE_SE != ""
        # Atualiza a tela de acordo com a velocidade
        for i in 0...@text_speed-1
          Graphics.update
        end
      end
      # Quebra o loop se estiver exibindo rápido
      break unless @show_fast or @line_show_fast
    end
  end
end

#==============================================================================
# Scene_Map
#------------------------------------------------------------------------------
# Classe das operações nos mapas.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# * Alias do método: start.
#==============================================================================

class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # Alias da inicialização do processo
  #--------------------------------------------------------------------------
  alias vampyr_balloon_message_smap_start start
  #--------------------------------------------------------------------------
  # Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    # Roda o método original
    vampyr_balloon_message_smap_start
    # Define a janela de mensagem como o sprite de balão
    @message_window = Sprite_MessageBalloon.new
  end
end