#==============================================================================
# VMB ExtraOptions [VX]
#------------------------------------------------------------------------------
# Adiciona algumas configurações extra ao script Vampyr Message Balloon, criado
# por Vampyr.
#------------------------------------------------------------------------------
# Site        : http://www.mundorpgmaker.com.br/
# Autor       : Kyo Panda
# Versão      : 1.1
# Lançado em  : 16 de Junho de 2010
# Atualização : 29 de Junho de 2010
#==============================================================================

#==============================================================================
# Agradecimentos:
#------------------------------------------------------------------------------
# • Vampyr     : Criador do script Vampyr Message Balloon.
# • LORD @.N.D : Por verificar o bug da troca de mensagens.
# • Lady Loren : Pela localização de alguns bugs no Vampyr Message Balloon.
#==============================================================================

#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# • Permite à você deixar que a mensagem apareça primariamente sobre o evento
#   que a chamou.
# • Restaura a função de exibição de faces nas mensagens.
# • Permite desenhar as pontas das mensagens arredondadas.
# • Permite a troca entra a mensagem em forma de balão e a mensagem padrão do
#   RPG Maker VX por switch
# • Corrige a lentidão dada pela velocidade das mensagens.
# • Restaura a opção de escolhas nas mensagens.
# • Restaura as opções de cores padrão das mensagens.
# • Adiciona a opção de adicionar windowskin nas mensagens.
# • Restaura a sombra de textos das mensagens.
# • Corrigido a função de troca de mensagem normal para balão por switch.
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação
# #--------------------------------------------------------------------------
#
# • Cole esse script abaixo do script "Vampyr Message Balloon" e acima do
#   "▼ Principal" no Editor de Scripts do RPG Maker VX.
#
# • Configure esse script no guia "Configuração" logo abaixo se desejado.
#
#==============================================================================

#==============================================================================
# Histórico de versões:
#------------------------------------------------------------------------------
# • Versão 1.1: 29 de Junho de 2010:
#   * Corrigido a função de troca de mensagem normal para balão por switch.
# • Versão 1.0: 16 de Junho de 2010:
#   * Primeira versão do script.
#   * Permite à você deixar que a mensagem apareça primariamente sobre o
#     evento que a chamou.
#   * Restaura a função de exibição de faces nas mensagens.
#   * Permite desenhar as pontas das mensagens arredondadas.
#   * Permite a troca entra a mensagem em forma de balão e a mensagem padrão
#     do RPG Maker VX por switch
#   * Corrige a lentidão dada pela velocidade das mensagens.
#   * Restaura a opção de escolhas nas mensagens.
#   * Restaura as opções de cores padrão das mensagens.
#   * Adiciona a opção de adicionar windowskin nas mensagens.
#   * Restaura a sombra de textos das mensagens.
#==============================================================================

#==============================================================================
# VMB_ExtraOptions
#------------------------------------------------------------------------------
# Módulo que armazena configurações extra para o script Vampyr Message Ballon.
#==============================================================================

module VMB_ExtraOptions
  #--------------------------------------------------------------------------
  # Configuração
  #--------------------------------------------------------------------------

  # Defina aqui se a mensagem deve estar posicionada, primáriamente, sobre
  # o evento que a chamou, ao invés de estar acima do personagem.
  # Isso agiliza a criação de eventos que simplesmente exibem uma mensagem
  # simples quando acionados.
  # Caso definido que sim, para exibir a mensagem acima do personagem, apenas
  # defina o comando de mensgem \EV[X] como 0.
  # Defina true para sim e false para não.
  ON_EVENT_CALLER = true

  # Defina aqui se deseja que faces sejam exibidas nas mensagens.
  # Defina true para sim e false para não.
  SHOW_MESSAGE_FACES = true

  # Tamanho do raio da ponta da mensagem, se desejar usar mensagens
  # com pontas arredondadas.
  # Defina como 0, se desejar utilizar as pontas padrões
  ROUND_RADIUS = 10

  # Defina aqui a switch que ativará e desativará o recurso de mensagem em
  # balão. Quando ligado: Mensagem Normal, quando desligado: Balão.
  # Defina como 0 para não utilizar esta função.
  BALLOON_SWITCH = 1

  # Primariamente, quando você vai definir uma nova mensagem, seu
  # posicionamento padrão é abaixo, o que fica estranho quando utilizado
  # com o VMB. Logo, ative esta opção para que, quando a mensagem for
  # definida para exibir abaixo, exiba-a acima, e vice-versa.
  # Como a ON_EVENT_CALLER, esta opção agiliza a criação de eventos
  # Defina true para sim e false para não.
  FLIP_UP_DOWN = true

  # Defina aqui se deseja utilizar uma Windowskin no lugar do balão padrão.
  # Se optar por utilizar a Windowskin, tanto o balão quanto a sua ponta se
  # tornarão invisível. Mas, há como você definir setas em forma de imagens.
  # Veja abaixo, como fazer isso.
  # Defina true para usar e false para não usar.
  USE_WINDOWSKIN = false

  # Para definir uma seta em forma de imagem, apenas defina aqui o prefixo
  # da imagem que você deseja, e após isso adicione as imagens à pasta
  # Graphics/Pictures do seu projeto com o mesmo prefixo da imagem,
  # adicionando _Up para acima e _Down para abaixo.
  # Por exemplo, se o prefixo for "Message_Point", deverá haver duas imagens
  # de ponta na pasta Graphics/Pictures com os seguintes nomes:
  #     Message_Point_Up   : Acima
  #     Message_Point_Down : Abaixo
  # Defina como "" para não utilizar as pontas.
  ARROW_PREFIX = "Message_Point"

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

#==============================================================================
# Game_Interpreter
#------------------------------------------------------------------------------
# Esta classe interpreta os comandos de evento e os transforma no código da
# engine do RPG Maker. As classes Game_Map, Game_Troop, Game_Event são usadas.
#==============================================================================

class Game_Interpreter
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :event_id
  #--------------------------------------------------------------------------
  # Alias da inicialização do objeto
  #--------------------------------------------------------------------------
  alias vmb01_initialize initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #     depth : profundidade
  #     main  : principal
  #--------------------------------------------------------------------------
  def initialize(depth = 0, main = false)
    # Chama o método original
    vmb01_initialize(depth, main)
    # Define o ID do evento que o executa
    @event_id = 0
  end
end

#==============================================================================
# Ellipse
#------------------------------------------------------------------------------
# Armazena um objeto elíptico.
#==============================================================================

class Ellipse
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader   :a # A largura do círculo
  attr_reader   :b # A altura do círculo
  attr_reader   :x # O posicionamento horizontal
  attr_reader   :y # O posicionamento vertical
  attr_reader   :h # O posicionamento horizontal em sua origem
  attr_reader   :k # O posicionamento vertical em sua origem
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #   x : o posicionamento horizontal
  #   y : o posicionamento vertical
  #   a : a largura do círculo em sua origem do seu lado
  #   b : a altura do círculo em sua origem. Se nil, é o radius do círculo
  #--------------------------------------------------------------------------
  def initialize (x, y, a, b = nil)
    @x = x
    @y = y
    @a = a
    @b = b.nil? ? a : b
    @h = x + a
    @k = y + @b
  end
  #--------------------------------------------------------------------------
  # Em conjunto?
  #   x : a coordenada horizontal sendo testada
  #   y : a coordenada vertical sendo testada
  #--------------------------------------------------------------------------
  def within? (x, y)
    x_square = ((x - @h)*(x - @h)).to_f / (@a*@a)
    y_square = ((y - @k)*(y - @k)).to_f / (@b*@b)
    # Se "radius" <= 1, então isso deve estar em conjunto com a ellipse
    return (x_square + y_square) <= 1
  end
end

#==============================================================================
# Bitmap
#------------------------------------------------------------------------------
# Classe que comanda toda e qualquer imagem exibida no jogo.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novos métodos: outiline_ellipse, fill_ellipse e fill_rounded_rect.
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # Contorno da elipse
  #   ellipse : a elipse sendo desenhada
  #   width   : a largura da barra
  #   colour  : a cor do contorno
  #--------------------------------------------------------------------------
  def outline_ellipse (ellipse, colour = font.color, width = 1, steps = 0)
    # Para organização, define as variáveis locais a e b para as variáveis de elipse
    a, b = ellipse.a, ellipse.b
    # Usa a aproximação de Ramanujan para a circunferência da elipse
    steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
    radian_modifier = (2*Math::PI) / steps
    for i in 0...steps
      t = (radian_modifier*i) % (2*Math::PI)
      # Expressada parametricamente:
      #   x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
      x = (ellipse.h + (a*Math.cos(t)))
      y = (ellipse.k + (b*Math.sin(t)))
      set_pixel (x, y, colour)
    end
    # Reforça a linha
    if width > 1
      ellipse = Ellipse.new (ellipse.x + 1, ellipse.y + 1, ellipse.a - 1, ellipse.b - 1)
      outline_ellipse (ellipse, colour, width - 1, steps)
    end
  end
  #--------------------------------------------------------------------------
  # Preenche a elipse
  #   ellipse : a elipse sendo desenhada
  #   colour  : a cor do contorno
  #--------------------------------------------------------------------------
  def fill_ellipse (ellipse, colour = font.color, steps = 0)
    # Para organização, define as variáveis locais a e b para as variáveis de elipse
    a, b = ellipse.a, ellipse.b
    # Usa a aproximação de Ramanujan para a circunferência da elipse
    steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
    radian_modifier = (2*Math::PI) / steps
    for i in 0...(steps / 2)
      t = (radian_modifier*i) % (2*Math::PI)
      # Expressada parametricamente:
      #   x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
      x = ellipse.h + (a*Math.cos(t))
      y = ellipse.k - (b*Math.sin(t))
      fill_rect (x, y, 1, 2*(ellipse.k - y), colour)
    end
  end
  #--------------------------------------------------------------------------
  # Preenche retângulo circular
  #   rect    : o retângulo sendo desenhado
  #   colour  : a cor do contorno
  #   w       : o número de pixels para cobrir o círculo
  #--------------------------------------------------------------------------
  # Usado para preencher retângulos com cantos circulares
  #--------------------------------------------------------------------------
  def fill_rounded_rect (rect, colour = font.color, w = 8)
    # Desenha o corpo do retângulo
    fill_rect (rect.x + w, rect.y, rect.width - 2*w, rect.height, colour)
    # Desenha o retângulo horizontal
    fill_rect (rect.x, rect.y + w, w, rect.height - 2*w, colour)
    # Desenha o retângulo vertical
    x = rect.x + rect.width - w
    fill_rect (x, rect.y + w, w, rect.height - 2*w, colour)
    # Faz um círculo
    circle = Ellipse.new (0, 0, w)
    for i in 0...w
      for j in 0...w
        # Canto superior esquerdo
        set_pixel (rect.x + i, rect.y + j, colour) if circle.within? (i, j)
        # Canto superior direito
        set_pixel (rect.x + rect.width - w + i, rect.y + j, colour) if circle.within? (i + w, j)
        # Canto inferior esquerdo
        set_pixel (rect.x + i, rect.y + rect.height - w + j, colour) if circle.within? (i, j + w)
        # Canto inferior direito
        set_pixel (rect.x + rect.width - w + i, rect.y + rect.height - w + j, colour) if circle.within? (i + w, j + w)
      end
    end
  end
end

#==============================================================================
# Window_RectChoice
#------------------------------------------------------------------------------
# Janela que serve de retãngulo de escolha.
#==============================================================================

class Window_RectChoice < Window_Selectable
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor   :item_max                 # Máximo de items
  attr_accessor   :index                    # Posição do cursor
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #     x      : alinhamento horizontal da janela
  #     y      : alinhamento vertical da janela
  #     width  : largura da janela
  #     height : altura da janela
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    # Define os valores da janela
    super(x, y, width, height)
    # Define a janela como trnasparente
    self.opacity = 0
    # Define a prioridade da janela
    self.z = 2000
    # Define o index da janela
    self.index = 0
    # Define se a janela está ativa ou não
    self.active = true
  end
  #--------------------------------------------------------------------------
  # Atualização do cursor
  #--------------------------------------------------------------------------
  def update_cursor
    # Define o cursor da janela
    cursor_rect.set(0, 0, contents.width, contents.height)
  end
end

#==============================================================================
# Sprite_MessageBALLOON
#------------------------------------------------------------------------------
# Sprite que exibe as mensagens em forma de balão.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# * Métodos sobrescritos: open, update e update_message.
# * Alias dos métodos   : reset e convert_special_characters.
# * Novos métodos       : start_choice, input_choice, terminate_messagem,
#                         update_cursor e text_color
#==============================================================================

class Sprite_MessageBalloon < Sprite
  #--------------------------------------------------------------------------
  # Inclusão das constantes e métodos do módulo VMB_ExtraOptions
  #--------------------------------------------------------------------------
  include VMB_ExtraOptions
  #--------------------------------------------------------------------------
  # Alias da reinicialização da mensagem
  #--------------------------------------------------------------------------
  alias vmb01_reset reset
  #--------------------------------------------------------------------------
  # Reinicialização da mensagem
  #--------------------------------------------------------------------------
  def reset
    # Roda o método original
    vmb01_reset
    # Define o alinhamento vertical do texto
    @contents_y = 8
  end
  #--------------------------------------------------------------------------
  # Exibição do ícone
  #     icon_index : número do ícone
  #     x          : exibe na coordenada X
  #     y          : exibe na coordenada Y
  #     enabled    : um espaço permitido. Fica transparente quando falso
  #--------------------------------------------------------------------------
  def draw_icon(icon_index, x, y, enabled = true)
    bitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.bitmap.blt(x, y, bitmap, rect, enabled ? 255 : 128)
  end
  #--------------------------------------------------------------------------
  # Abrir
  #--------------------------------------------------------------------------
  def open
    # Se definir como abrir mensagens acima dos eventos que as chamous
    if ON_EVENT_CALLER
      # Define o @character como o evento
      @character = $game_map.events[$game_map.interpreter.event_id]
    # Se não
    else
      # Define o @character como o personagem
      @character = $game_player
    end
    # Para cada i de 0 ao tamanho do texto à ser exibido
    for i in 0...$game_message.texts.size
      # Adiciona um espaço se iniciado uma escolha
      @text += "　　" if i >= $game_message.choice_start
      # Clona-se o i referente à string do texto
      @text += $game_message.texts[i].clone + "\x00"
    end
    # Define o @item_max de acordo com a quantidade de escolhas
    @item_max = $game_message.choice_max
    # Define a largura extra da mensagem pelas escolhas
    cw = $game_message.choice_max > 0 ? 16 : 0
    # Converte os caracteres especiais
    convert_special_characters
    # Para cada i do texto, separa-se o texto
    for i in @text.split("\x00")
      # Para cada texto separado, adquire-se o seu tamanho
      @width << @text[i].getw
    end
    # Define-se a altura do texto
    height = $game_message.texts.size * 24 + (24 + 8)
    # Se definir utilizar faces nas mensagens, define o valor padrão
    if $game_message.face_name.empty?
      fw = 0
      fh = 0
    else
      fw = SHOW_MESSAGE_FACES ? 108 : 0
      fh = SHOW_MESSAGE_FACES ? 88 : 0
    end
    # Se não houver face na mensagem, desenha a mensagem normal
    # Define uma nova altura de acordo com a face
    if SHOW_MESSAGE_FACES
      if !$game_message.face_name.empty?
        if height < 132
          height = 40
        else
          height = height - 124
        end
      end
    end
    # Define o bitmap do texto de acordo com a altura e largura definida
    self.bitmap = Bitmap.new(@width.max + 8 + fw + cw, height + fh)
    # Define-se a fonte da mensagem
    self.bitmap.font.name = FONT_NAME
    # Define-se o tamanho da fonte da mensagem
    self.bitmap.font.size = FONT_SIZE
    # Define-se se deve adicionar sombra a fonte da mensagem
    self.bitmap.font.shadow = FONT_SHADOW
    # Define-se a cor do texto da mensagem
    self.bitmap.font.color = FONT_COLOR
    # Realiza a compensação horizontal
    self.ox = self.bitmap.width / 2
    # Realiza a compensação vertical
    self.oy = self.bitmap.height / 2
    # Define-se um Rect de acordao com a largura e altua do bitmap
    rect = self.bitmap.rect.clone
    # Diminui-se em 16 pixels o tamanho do retângulo
    rect.height -= 16
    # Cria-se o valor de posicionamento da janela
    position_v = FLIP_UP_DOWN ? 0 : 2
    # Define-se a opacidade do bitmap, se houver windowskin
    o = USE_WINDOWSKIN ? 0 : 192
    # Cria a ponta do balão de mensagem
    # Se estiver acima
    if $game_message.position == position_v
      q = [7, 6, 5, 4, 3, 2, 1, 0]
      for p in 0 .. 7
        self.bitmap.fill_rect(self.ox - 4, p, 8 - q[p], 1, Color.new(255, 255, 255, o))
      end
    # Se não estiver acima
    else
      q = [7, 6, 5, 4, 3, 2, 1, 0]
      for p in 0 .. 7
        self.bitmap.fill_rect(self.ox - 4, rect.height + p, q[p], 1, Color.new(255, 255, 255, o))
      end
    end
    # Se definido não utilizar a mensagem arredondada
    if !ROUND_RADIUS.is_a?(Integer) || ROUND_RADIUS <= 0
      # Desenha a mensagem padrão
      self.bitmap.fill_rect(rect, Color.new(255, 255, 255, o))
    # Se não
    else
      # Desenha a mensagem arredondada
      self.bitmap.fill_rounded_rect(rect, Color.new(255, 255, 255, o), ROUND_RADIUS)
    end
    # Se usar windowskin, define a windowskin da janela
    if USE_WINDOWSKIN
      @windowskin = Window_Base.new(rect.x - (self.bitmap.width / 2) - 16,
      rect.y - (self.bitmap.height / 2) - 16, rect.width + 16,
      rect.height + 16)
    end
    # Se o prefixo de seta for uma String e não for nula e se houver windowskin
    if ARROW_PREFIX.is_a?(String) && !ARROW_PREFIX.empty? && !@windowskin.nil?
      # Define as setas
      @arrow_up = Sprite.new
      @arrow_down = Sprite.new
      # Deixa ambas as setas invisíveis
      @arrow_up.visible = false
      @arrow_down.visible = false
      # Define a prioridade das setas
      @arrow_up.z = 2000
      @arrow_down.z = 2000
      # Define o bitmap das setas
      @arrow_up.bitmap = Cache.picture("#{ARROW_PREFIX}_Up")
      @arrow_down.bitmap = Cache.picture("#{ARROW_PREFIX}_Down")
      # Define o posicionamento das setas, de acordo com o posicionamento da janela
      @arrow_up.x = @windowskin.x + @windowskin.width / 2 - @arrow_up.bitmap.width / 2
      @arrow_up.y = @windowskin.y - @arrow_up.bitmap.height + 6
      @arrow_down.x = @windowskin.x + @windowskin.width / 2 - @arrow_down.bitmap.width / 2
      @arrow_down.y = @windowskin.y + @windowskin.height - 6
      # Exibe a seta de acordo com a posição da mensagem
      # Se for acima
      if $game_message.position == position_v
        @arrow_up.visible = true
      # Se não estiver acima
      else
        @arrow_down.visible = true
      end
    end
    # Define-se a opacidade da janela
    self.opacity = 255
    # Exibe a face da mensagem, se assim definido
    if SHOW_MESSAGE_FACES
      if !$game_message.face_name.empty?
        name = $game_message.face_name
        index = $game_message.face_index
        face = Cache.face(name)
        rect = Rect.new(0, 0, 0, 0)
        rect.x = index % 4 * 96
        rect.y = index / 4 * 96
        rect.width = 96
        rect.height = 96
        bitmap.blt(8, 8, face, rect)
        face.dispose
        @contents_x = 112
      end
    end
    # Define-se a mensagem como visível
    self.visible = true
    # Marca a mensagem como visível
    $game_message.visible = true
  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 estiver ativa as escolhas
    if @active
      # Atualiza o cursor
      update_cursor
      # Atualiza o retângulo do cursor
      @cursor_rect.update
      # Atualiza a inserção de comandos
      input_choice
    # Se estiver apagando a mensagem
    elsif @erasing
      # Se estiver usando windowskin
      if USE_WINDOWSKIN
        # Se a opacidade da mensagem for maior que 0
        if @windowskin.opacity > 0
          # Reduz-se a opacidade em 10.
          @windowskin.opacity -= 10
          # Se a opacidade da mensagem for maior que 0
          if self.opacity > 0
            # Reduz-se a opacidade em 10.
            self.opacity -= 10
          end
          # Se o prefixo de seta for uma String e não for nula e se houver windowskin
          if ARROW_PREFIX.is_a?(String) && !ARROW_PREFIX.empty? && !@windowskin.nil? &&
          !@arrow_up.nil? && !@arrow_down.nil?
            # Apaga as setas
            if @arrow_up.opacity > 0
              @arrow_up.opacity -= 10
            end
            if @arrow_down.opacity > 0
              @arrow_down.opacity -= 10
            end
          end
        # Se não
        else
          # Fecha a mensagem
          @erasing = false
          terminate_message
        end
      # Se não estiver usando windowskin
      else
        # 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
          @erasing = false
          terminate_message
        end
      end
    # Se a contagem de espera for mais que 0
    elsif @wait_count > 0
      # Reduz-se a contagem de espera em 1
      @wait_count -= 1
    # Se a mensagem estiver terminando
    elsif @terminate_message
      # Se houver escolhas, inicia-as
      if $game_message.choice_max > 0
        start_choice
      else
        terminate_message
      end
      @wait_count = 10
      @text = nil
    # Se a mensagem estiver fechando
    elsif @closing
      # Se pressionar C ou B ou se haver escolhas
      if Input.trigger?(Input::C) or Input.trigger?(Input::B) or
        $game_message.choice_max > 0
        # 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
    # Cria-se o valor de posicionamento da janela
    position_v = FLIP_UP_DOWN ? 0 : 2
    # Se estiver exibindo acima
    if $game_message.position == position_v
      # 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 / 2) - 24 - 32
      # self.y = @character.screen_y - (self.bitmap.height / 2) - 24
    end
    # Se estiver utilizando windowskin, posiciona a windowskin de acordo
    if USE_WINDOWSKIN
      # Define X como o posicionamento de @character
      @windowskin.x = @character.screen_x - (self.bitmap.width / 2) - 8
      # Se estiver exibindo acima
      if $game_message.position == position_v
        # Define o posicionamento de acordo
        @windowskin.y = @character.screen_y + (self.bitmap.height / 2) + 8 - (self.bitmap.height / 2) - 8
      # Se não
      else
        # Define o posicionamento de acordo
        @windowskin.y = @character.screen_y - (self.bitmap.height / 2) - 24 - (self.bitmap.height / 2) - 8 - 32
        # @windowskin.y = @character.screen_y - (self.bitmap.height / 2) - 24 - (self.bitmap.height / 2) - 8
      end
      # Se o prefixo de seta for uma String e não for nula e se houver windowskin
      if ARROW_PREFIX.is_a?(String) && !ARROW_PREFIX.empty? && !@windowskin.nil? &&
        !@arrow_up.nil? && !@arrow_down.nil?
        # Deixa as duas setas invisíveis
        @arrow_up.visible = false
        @arrow_down.visible = false
        # Define o posicionamento das setas, de acordo com o posicionamento da janela
        @arrow_up.x = @windowskin.x + @windowskin.width / 2 - @arrow_up.bitmap.width / 2
        @arrow_up.y = @windowskin.y - @arrow_up.bitmap.height + 6
        @arrow_down.x = @windowskin.x + @windowskin.width / 2 - @arrow_down.bitmap.width / 2
        @arrow_down.y = @windowskin.y + @windowskin.height - 6
        # Exibe a seta de acordo com a posição da mensagem
        # Se for acima
        if $game_message.position == position_v
          @arrow_up.visible = true
        # Se não estiver acima
        else
          @arrow_down.visible = true
        end
      end
    end
  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
        if $game_message.face_name.empty?
          @contents_x = 4
        else
          @contents_x = SHOW_MESSAGE_FACES ? 112 : 4
        end
        # Aumenta o alinhamento Y do conteúdo para mais o tamanho da fonte
        @contents_y += 24
        # 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
        # Memoriza a cor padrão da fonte
        base_color = self.bitmap.font.color.clone
        # Define a cor escura
        self.bitmap.font.color = Color.new(0, 0, 0, base_color.alpha)
        # Desenha o texto um  pouco escuro, para a sombra da mensagem
        self.bitmap.draw_text(@contents_x + 1, @contents_y + 1, 20, FONT_SIZE, c)
        # Redefine a cor da fonte
        self.bitmap.font.color = base_color
        # Desenha o texto normal
        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 != ""
      end
      # Quebra o loop se estiver exibindo rápido
      break unless @show_fast or @line_show_fast
    end
  end
  #--------------------------------------------------------------------------
  # Alias da conversão dos caracteres especiais
  #--------------------------------------------------------------------------
  alias vmb01_convert_special_characters convert_special_characters
  #--------------------------------------------------------------------------
  # Conversão dos caracteres especiais
  #--------------------------------------------------------------------------
  def convert_special_characters
    # Se for a mudança do posicionamento de eventos, se o ID for nulo,
    # define o @character como o personagem
    @text.gsub!(/\\EV\[(\d+)\]/i){@character = $game_map.events[$1.to_i].nil? ?
    $game_player : $game_map.events[$1.to_i]; ""}
    # Roda o método padrão
    vmb01_convert_special_characters
  end
  #--------------------------------------------------------------------------
  # Iniciar escolha
  #--------------------------------------------------------------------------
  def start_choice
    # Define a mensagem como ativa, para escolhas
    @active = true
    # Se houver faces
    if SHOW_MESSAGE_FACES
      # Define a largura do cursor de acordo
      width = $game_message.face_name.empty? ? self.bitmap.width + 32 :
      self.bitmap.width + 32 - 108
    # Se não houver faces
    else
      # Define a largura do cursor de acordo
      width = self.bitmap.width + 32
    end
    # Cria o cursor pela janela de cursor
    @cursor_rect = Window_RectChoice.new(0, 0, width - 16, 56) if @cursor_rect.nil?
    # Define o @item_max da janela de acordo com o número de mensagens
    @cursor_rect.item_max = @item_max
  end
  #--------------------------------------------------------------------------
  # Inserção: escolha
  #--------------------------------------------------------------------------
  def input_choice
    # Se cancelar
    if Input.trigger?(Input::B)
      # Se o cancelamento da mensagem for por botão
      if $game_message.choice_cancel_type > 0
        # Toca o som de cancelamento
        Sound.play_cancel
        # Chama o processo de cancelamento
        $game_message.choice_proc.call($game_message.choice_cancel_type - 1)
        # Finaliza a mensagem
        terminate_message
      end
    # Se confirmar
    elsif Input.trigger?(Input::C)
      # Toca o som de confirmação
      Sound.play_decision
      # Chama o processo correspondente ao index da escolha
      $game_message.choice_proc.call(@cursor_rect.index)
      # Finaliza a mensagem
      terminate_message
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do cursor
  #--------------------------------------------------------------------------
  def update_cursor
    # Se o index for maior que 0
    if @cursor_rect.index >= 0
      # Se exibir faces
      if SHOW_MESSAGE_FACES
        # Define o posicionamento horizontal de acordo
        x = $game_message.face_name.empty? ?
        self.x - (self.bitmap.width / 2) : self.x - (self.bitmap.width / 2) + 108
      # Não exibir faces
      else
        # Define o posicionamento horizontal de acordo
        x = self.x - (self.bitmap.width / 2)
      end
      # Define o posicionamento vertical do cursor
      y = (self.y - (self.bitmap.height / 2)) +
      (($game_message.choice_start + @cursor_rect.index) * 24) - 12
      # Define o posicionamento do cursor
      @cursor_rect.x = x - 8
      @cursor_rect.y = y
    end
  end
  #--------------------------------------------------------------------------
  # Fim da mensagem
  #--------------------------------------------------------------------------
  def terminate_message
    @active = false
    # Fecha a janela de cursor se não for nula
    if !@cursor_rect.nil?
      @cursor_rect.dispose
      @cursor_rect = nil
    end
    # Se estiver usando windowskin
    if USE_WINDOWSKIN
      # Se a opacidade da mensagem for maior que 0
      if @windowskin.opacity > 0
        # Marca o apagamento da mensagem
        @erasing = true
      else
        # Chama o processo principal da mensagem
        $game_message.main_proc.call if $game_message.main_proc != nil
        # Limpa a mensagem
        $game_message.clear
        # Fecha a mensagem
        close
        # Define a mensagem como invisível
        $game_message.visible = false
        # Faz o dispose da windowskin
        # @windowskin.dispose
        # Faz o dispose das setas
        @arrow_up.dispose if !@arrow_up.nil?
        @arrow_down.dispose if !@arrow_down.nil?
      end
    # Se não estiver usando windowskin
    else
      # Se a opacidade da mensagem for maior que 0
      if self.opacity > 0
         # Marca o apagamento da mensagem
        @erasing = true
      else
        # Chama o processo principal da mensagem
        $game_message.main_proc.call if $game_message.main_proc != nil
        # Limpa a mensagem
        $game_message.clear
        # Fecha a mensagem
        close
        # Define a mensagem como invisível
        $game_message.visible = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # Configuração da cor da letra
  #     n : cor da letra (0～31)
  #--------------------------------------------------------------------------
  def text_color(n)
    # Posicionamento horizontal da cor na paleta da windowskin
    x = 64 + (n % 8) * 8
    # Posicionamento vertical da cor na paleta da windowskin
    y = 96 + (n / 8) * 8
    # Define a windowskin
    windowskin = Cache.system("Window")
    # Retorna o valor da paleta
    return windowskin.get_pixel(x, y)
  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 do início do processo
  #--------------------------------------------------------------------------
  alias vampyr_balloon_message_smap2_start start
  #--------------------------------------------------------------------------
  # Início do processo
  #--------------------------------------------------------------------------
  def start
    # Chama o método padrão
    vampyr_balloon_message_smap2_start
    @balloon_message = Sprite_MessageBalloon.new
    @normal_message  = Window_Message.new
    @memo_switch = $game_switches[VMB_ExtraOptions::BALLOON_SWITCH]
    # Se a switch de balões não for nula e estiver ativada
    if !$game_switches[VMB_ExtraOptions::BALLOON_SWITCH].nil? &&
        $game_switches[VMB_ExtraOptions::BALLOON_SWITCH]
      # Define a mensagem como padrão
      @message_window = @normal_message
    # Se não
    else
      # Define a mensagem como balão
      @message_window = @balloon_message
    end
  end
  #--------------------------------------------------------------------------
  # Alias da atualização da tela
  #--------------------------------------------------------------------------
  alias vampyr_balloon_message_smap2_update update
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    # Chama o método padrão
    vampyr_balloon_message_smap2_update
    if @memo_switch != $game_switches[VMB_ExtraOptions::BALLOON_SWITCH]
       # Se a switch de balões não for nula e estiver ativada
      if !$game_switches[VMB_ExtraOptions::BALLOON_SWITCH].nil? &&
          $game_switches[VMB_ExtraOptions::BALLOON_SWITCH]
        # Retorna se estiver visivel
        return if $game_message.visible
        # Define a mensagem como padrão
        @message_window = @normal_message
      # Se não
      else
        # Retorna se estiver visivel
        return if $game_message.visible
        # Define a mensagem como balão
        @message_window = @balloon_message
      end
      @memo_switch = $game_switches[VMB_ExtraOptions::BALLOON_SWITCH]
    end
  end
end