Sistema De Guia de Monstros

Este é um script criado por SephirothSpawn para o RPG Maker XP, que cria um Guia de Monstros estilo Poke-DEX com informações sobre os inimigos como HP, MP, GOLD, itens, fraquezas… Enfim, um perfil razoavelmente completo de cada monstro.

Screenshots

Instruções

Cole o script acima do Main. Para ativar, chame-o com: $scene = Scene_Beastairy.new

Código

#==============================================================================
# Sistema de Guia de Monstros
#--------------------------------------------------------------------------
#   Criado por SephirothSpawn (11.18.05)
#   Ultima Atualização: 11.18.05
#   class.rgss
#==============================================================================
# DESCRIÇÃO
#==============================================================================
# Este Script cria um Guia de Monstros estilo Poke-DEX com informações
# sobre os inimigos como hp, mp, gold, itens, fraquesas um perfil completo
#==============================================================================
# INSTRUÇÕES
#==============================================================================
# Cole este Script Acima do main!
# Para Ativalo chame-o com: $scene = Scene_Beastairy.new
#==============================================================================
# ** Classe Scene Title
#==============================================================================
class Scene_Title
  #--------------------------------------------------------------------------
  # * Alias' Novo Game / Metodo
  #--------------------------------------------------------------------------
  alias new_game command_new_game
  #--------------------------------------------------------------------------
  # * Adiciona ao Game Variaveis do Beastairy
  #--------------------------------------------------------------------------
  def command_new_game
    # Sets Up Smithery List
    $game_beastairy = Game_Beastairy.new
    new_game
  end
end

#==============================================================================
# ** Game_Temp
#==============================================================================
class Game_Temp
  #--------------------------------------------------------------------------
  # * Publica Variavies de Instancia
  #--------------------------------------------------------------------------
  attr_accessor :beastairy_return
  #--------------------------------------------------------------------------
  # * Inicialização Alias 
  #--------------------------------------------------------------------------
  alias beastairy_initialize initialize
  #--------------------------------------------------------------------------
  # * Inicialização de Objetos
  #--------------------------------------------------------------------------
  def initialize
    beastairy_initialize
    @beastairy_return = false
  end
end

#==============================================================================
# ** Classe Game Guia de Monstros
#==============================================================================
class Game_Beastairy
  #--------------------------------------------------------------------------
  # * Publica Variavies de Instancia
  #--------------------------------------------------------------------------
  attr_accessor :monster_groups
  #--------------------------------------------------------------------------
  # * Inicialização de Objetos
  #--------------------------------------------------------------------------
  def initialize
    @monster_groups = []
    for i in 1...$data_enemies.size
      $data_enemies[i].beastairy_setup
      unless @monster_groups.include?($data_enemies[i].group)
        @monster_groups.push($data_enemies[i].group)
      end
    end
  end
end

#==============================================================================
# ** Modulo RPG
#==============================================================================
module RPG
  #=========================================================================
  # ** Classe Inimigo
  #=========================================================================
  class Enemy
    #--------------------------------------------------------------------------
    # * Publica Variavies de Instancia
    #--------------------------------------------------------------------------
    # Detectors
    attr_accessor :seen, :defeated, :group
    # Counters
    attr_accessor :seen_times, :defeated_times
    #--------------------------------------------------------------------------
    # * Setup do Guia de Monstros
    #--------------------------------------------------------------------------
    def beastairy_setup
      @seen_times, @defeated_times = 0, 0
      @seen, @defeated = false, false
      if @name.include?('(')
        a, b = @name.index('('), @name.index(')')
        @group = @name.slice!(a..b)
        @group.delete!('(')
        @group.delete!(')')
      else
        @group = "Sem Classificação"
      end
    end
    #--------------------------------------------------------------------------
    # * Viu Inimigo
    #--------------------------------------------------------------------------
    def see
      @seen = true
      @seen_times += 1
    end
    #--------------------------------------------------------------------------
    # * Matou o Inimigo
    #--------------------------------------------------------------------------
    def defeat
      @defeated = true
      @defeated_times += 1
    end
  end
end

#==============================================================================
# ** Scene_Save
#==============================================================================
class Scene_Save < Scene_File
  #--------------------------------------------------------------------------
  # * Alias Salva Dados
  #--------------------------------------------------------------------------
  alias new_save write_save_data
  #--------------------------------------------------------------------------
  # * Escreve Dados Salvos
  #--------------------------------------------------------------------------
  def write_save_data(file)
    new_save(file)
    Marshal.dump($game_beastairy, file)
  end
end

#==============================================================================
# ** Scene_Load
#==============================================================================
class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Alias Lê Dados salvos
  #--------------------------------------------------------------------------
  alias new_load read_save_data
  #--------------------------------------------------------------------------
  # * Lê Arquivos Salvos
  #--------------------------------------------------------------------------
  def read_save_data(file)
    new_load(file)
    $game_beastairy = Marshal.load(file)
  end
end

#==============================================================================
# ** Classe Window Base
#==============================================================================
class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Pega O Sprite Inimigo
  #--------------------------------------------------------------------------
  def draw_enemy_sprite(x, y, enemy_name, enemy_hue, pose, frame)
    bitmap = RPG::Cache.character(enemy_name, enemy_hue)
    cw = bitmap.width / 4
    ch = bitmap.height / 4
    # Olhando para:
    case pose
      when 0    ;a = 0             # Baixo
      when 1    ;a = ch           # Esquerda
      when 2    ;a = ch * 3      # Cima
      when 3    ;a = ch * 2      # Direita
    end
    # Animação decorrente
    case frame
      when 0    ;b = 0
      when 1    ;b = cw
      when 2    ;b = cw * 2
      when 3    ;b = cw * 3
    end
    # Bitmap Rectange
    src_rect = Rect.new(b, a, cw, ch)
    # Pega o  Bitmap
    self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
  end
end

#==============================================================================
# Janela de Informações sobre o Grupo dos Monstros
#==============================================================================
class Window_Monster_Group_Info < Window_Base
  #--------------------------------------------------------------------------
  # * Inicialização de Objetos
  #--------------------------------------------------------------------------
  def initialize
    super(200, 0, 440, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh(0, 0, 0)
  end
  #--------------------------------------------------------------------------
  # * Atualiza
  #     index  : Index dos grupos do Game_Beastairy.Groups
  #     pose   : Pose do Character do Inimigo
  #     frame  : Quadro da Pose
  #--------------------------------------------------------------------------
  def refresh(index, pose, frame)
    # Limpa Janelas
    contents.clear
    # Seta o nome do grupo
    group_name = $game_beastairy.monster_groups[index]
    # Seta o inimigo no grupo
    enemies = []
    for i in 1...$data_enemies.size
      if $data_enemies[i].group == group_name
        enemies.push($data_enemies[i])
      end
    end
    group_name = "Sair" if index == $game_beastairy.monster_groups.size
    # Puxa o nome do Grupo do Inimigo
    contents.font.color = system_color
    contents.draw_text(0, 0, self.width - 32, 32, group_name, 1)
    unless index == $game_beastairy.monster_groups.size
      # Graficos Offsets / Posição X 
      graphics_offset = contents.width / (enemies.size + 1)
      # Pega os Graficos do Inimigo
      for i in 0...enemies.size
        draw_enemy_sprite(graphics_offset * (i + 1), 124, enemies[i].battler_name , enemies[i].battler_hue , pose, frame)
      end
      # HP, SP, e Palavra Gold
      hp_word = $data_system.words.hp
      sp_word = $data_system.words.sp
      gold_word = $data_system.words.gold
      # Escreve os titulos dos atributos
      contents.draw_text(4, 128, width, 24, "Nome")
      contents.draw_text(0, 128, 200, 24, "Max #{hp_word}", 2)
      contents.draw_text(0, 128, 300, 24, "Max #{sp_word}", 2)
      contents.draw_text(-4, 128, contents.width, 24, "#{gold_word}old Ganho", 2)
      # Pega os Status do Inimigo
      contents.font.color = normal_color
      for i in 0...enemies.size
        # Seta os Status do Inimigo
        name, hp, sp, gold = "??????????", "???", "???", "?????"
        name, hp, sp = enemies[i].name, enemies[i].maxhp, enemies[i].maxsp if enemies[i].seen
        gold = enemies[i].gold if enemies[i].defeated
        # Desenha o Status
        contents.draw_text(4, 152 + (i * 24), width, 24, name)
        contents.draw_text(0, 152 + (i * 24), 200, 24, "#{hp}", 2)
        contents.draw_text(0, 152 + (i * 24), 300, 24, "#{sp}", 2)
        contents.draw_text(-4, 152 + (i * 24), contents.width, 24, "#{gold}", 2)
      end
    end
  end
end

#==============================================================================
# Janela de Informação do Monstro
#==============================================================================
class Window_Monster_Info < Window_Base
  #--------------------------------------------------------------------------
  # * Inicialização de Objetos
  #--------------------------------------------------------------------------
  def initialize
    super(200, 0, 440, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # * Atualização
  #     index  : Index do inmigo do $data_enemies
  #     Pose do Character do Inimigo
  #     frame  : Quadro da Pose
  #--------------------------------------------------------------------------
  def refresh(index, pose, frame)
    # Limpa Janelas
    contents.clear
    # Inimigo
    enemy = $data_enemies[index]
    # Imagens dos Graficos
    draw_enemy_sprite(52, 100, enemy.battler_name , enemy.battler_hue, pose, frame)
    # Falta de informaçoes
    name = "??????????"
    maxhp = maxsp =  str = dex = agi = int = atk = pdef = mdef = eva = "???"
    exp = gold = item_id = weapon_id = armor_id = treasure_prob = "?????"
    item_icon = weapon_icon = armor_icon = "049-Skill06"
    armor_type = 2
    # Se o inimigo já tiver sido encontrado(visto)
    if enemy.seen
      name = enemy.name
      maxhp = enemy.maxhp.to_s
      maxsp =  enemy.maxsp.to_s
      str = enemy.str.to_s
      dex = enemy.dex.to_s
      agi = enemy.agi.to_s
      int = enemy.int.to_s
      atk = enemy.atk.to_s
      pdef = enemy.pdef.to_s
      mdef = enemy.mdef.to_s
      eva = enemy.eva.to_s
    end
    # Se o Inimigo foi Derrotado
    if enemy.defeated
      exp = enemy.exp.to_s
      gold = enemy.gold.to_s
      if enemy.item_id == 0
        item_id = "Nenhum"
        item_icon = "032-Item01"
      else
        item_id = $data_items[enemy.item_id].name
        item_icon = $data_items[enemy.item_id].icon_name
      end
      if enemy.weapon_id == 0
        weapon_id = "Nenhum"
        weapon_icon = "032-Item01"
      else
        weapon_id = $data_weapons[enemy.weapon_id].name
        weapon_icon = $data_weapons[enemy.weapon_id].icon_name
      end
      if enemy.armor_id == 0
        armor_id = "Nenhum"
        armor_icon = "032-Item01"
      else
        armor_id = $data_armors[enemy.armor_id].name
        armor_icon = $data_armors[enemy.armor_id].icon_name
        armor_type = $data_armors[enemy.armor_id].type
      end
      treasure_prob = enemy.treasure_prob.to_s
    end
    # Sistemas de Palavras
    g_word = $data_system.words.gold 
    hp_word = $data_system.words.hp 
    sp_word = $data_system.words.sp 
    str_word = $data_system.words.str 
    dex_word = $data_system.words.dex 
    agi_word = $data_system.words.agi 
    int_word = $data_system.words.int 
    atk_word = $data_system.words.atk 
    pdef_word = $data_system.words.pdef 
    mdef_word = $data_system.words.mdef 
    weapon_word = $data_system.words.weapon
    case armor_type
      when 0     ;armor_type = $data_system.words.armor1
      when 1     ;armor_type = $data_system.words.armor2
      when 2     ;armor_type = $data_system.words.armor3
      when 3     ;armor_type = $data_system.words.armor4
    end
    item_word = $data_system.words.item 
    # Pega os nomes
    contents.font.color = normal_color
    contents.draw_text(116, 0, contents.width - 116, 32, name)
    # Pega as vezes que viu e que derrotou
    contents.font.color = system_color
    contents.draw_text(116, 32, contents.width - 116, 32, "Vezes que viu:")
    contents.draw_text(116, 64, contents.width - 116, 32, "Tempo de batalha:")
    contents.font.color = normal_color
    contents.draw_text(0, 32, contents.width, 32, "#{enemy.seen_times}", 2)
    contents.draw_text(0, 64, contents.width, 32, "#{enemy.defeated_times}", 2)
    # Organiza Status
    colomn_a_left = ["Max #{hp_word}", "Max #{sp_word}", str_word, dex_word, 
                     agi_word, int_word, atk_word, pdef_word, mdef_word, "Escapou"]
    colomn_a_right = [maxhp, maxsp, str,dex , agi, int, atk, pdef, mdef, eva]
    # Colocações de Vitória organizadas
    column_b_left = ["Experiencia Dada:", "#{g_word}old Pego:", "#{item_word} Pega:", "",
          "#{weapon_word} Pega:", "", "#{armor_type} Pega:", "", "Itens Probabilidade:"]
    column_b_right = [exp, gold, "", item_id, "", weapon_id, "", armor_id, treasure_prob]
    # Pega Status
    for i in 0...colomn_a_left.size
      contents.font.color = system_color
      contents.draw_text(4, 160 + i * 32, 160, 32, colomn_a_left[i])
      contents.font.color = normal_color
      contents.draw_text(-4, 160 + i * 32, 160, 32, colomn_a_right[i], 2)
    end
    # Pega Colocações de Vitória
    for i in 0...column_b_left.size
      contents.font.color = system_color
      contents.draw_text(168, 160 + i * 32, contents.width, 32, column_b_left[i])
      x = -4
      x = -30 if i == 3 or i == 5 or i == 7
      contents.font.color = normal_color
      contents.draw_text(x, 160 + i * 32, contents.width, 32, column_b_right[i], 2)
    end
    # Pega o Icones dos intens
    bitmap = RPG::Cache.icon(item_icon)
    self.contents.blt(contents.width - 24, 260, bitmap, Rect.new(0, 0, 24, 24))
    bitmap = RPG::Cache.icon(weapon_icon)
    self.contents.blt(contents.width - 24, 324, bitmap, Rect.new(0, 0, 24, 24))
    bitmap = RPG::Cache.icon(armor_icon)
    self.contents.blt(contents.width - 24, 388, bitmap, Rect.new(0, 0, 24, 24))
  end
end

#==============================================================================
# Janela dos Controles do Guia dos Monstros
#==============================================================================
class Window_Beastairy_Controls < Window_Base
  #--------------------------------------------------------------------------
  # * Inicialização de Objetos
  #--------------------------------------------------------------------------
  def initialize
    super(0, 288, 200, 192)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.z = 999
    refresh(0)
  end
  #--------------------------------------------------------------------------
  # * Atualiza
  #--------------------------------------------------------------------------
  def refresh(phase)
    # Limpa Janelas
    contents.clear
    disabled_system_color = Color.new(192, 224, 255, 128)
    contents.font.color = normal_color
    contents.draw_text(0, 0, contents.width, 24, "L / R : Mudar a Posição")
    # Controles principais
    contents.font.color = phase == 0 ? system_color : disabled_system_color
    contents.draw_text(4, 24, contents.width, 24, "Menu")
    contents.font.color = phase == 0 ? normal_color : disabled_color
    contents.draw_text(8, 48, contents.width, 24, "B : Retornar ao Mapa")
    contents.draw_text(8, 72, contents.width, 24, "C : Selecionar")
    # Inimigo Selecionado Controles
    contents.font.color = phase == 1 ? system_color : disabled_system_color
    contents.draw_text(4, 96, contents.width, 24, "Menu")
    contents.font.color = phase == 1 ? normal_color : disabled_color
    contents.draw_text(8, 120, contents.width, 24, "B : Retornar")
    contents.draw_text(8, 140, contents.width, 24, "C : Batalhar(Teste)")
  end
end

#==============================================================================
# ** Classe Scene Guia dos Monstros
#==============================================================================
class Scene_Beastairy
  #--------------------------------------------------------------------------
  # * Processo Principal
  #--------------------------------------------------------------------------
  def main
    # Seta Fase do menu
    @phase = 0
    # Animação grafica dos inimigos
    @pose, @frame, @counting_frame= 0, 0, 0
    # Janela / Fase atual
    @phase_window = Window_Base.new(0, 0, width = 200, height = 64)
      @phase_window.contents = contents = Bitmap.new(width - 32, height - 32)
      @phase_window.contents.draw_text(0, 0, 168, 32, "Menu Principal", 1)
    # Janela Principal (Janela dos Grupos)
    commands = $game_beastairy.monster_groups.dup
    commands.push("Sair")
    @enemy_groups = Window_Command.new(200, commands)
      @enemy_groups.y = 64
      @enemy_groups.height = 224
    # Controles da Janela
    @controls = Window_Beastairy_Controls.new
    # Grupo de monstros / Janela de informação
    @monster_window = Window_Monster_Group_Info.new
      @monster_window.refresh(0, 0, 0)
    # Janela de Informação do Inimigo
    @enemy_window = Window_Monster_Info.new
      @enemy_window.visible = false
    # Scene Obejto
    @objects = [@phase_window, @enemy_groups, @controls, @monster_window, @enemy_window]
    # Executar Transitions
    Graphics.transition
    # Loop do Processo
    loop do
      # Atualize tela de jogo
      Graphics.update
      # Atualiza Informações inseridas
      Input.update
      # Atualiza os Objetos
      @objects.each {|x| x.update}
      # Atualiza os Quadros (Frames)
      update
      # Cancela a Tela Mudada
      break if $scene != self
    end
    # Prepara Transição
    Graphics.freeze
    # Disponha de Objetos
    @objects.each {|x| x.dispose unless x.disposed?}
  end
  #--------------------------------------------------------------------------
  # * Atualização de Quadros (Frames)
  #--------------------------------------------------------------------------
  def update
    # Visualisa Mudança entre os Metodos
    case @phase
    # Fase Principal
    when 0
      [@enemy_window].each {|x| x.visible = false if x.visible}
      [@enemy_groups, @monster_window].each {|x| x.visible = true unless x.visible}
      @enemy_groups.active = true
    when 1
      [@enemy_window].each {|x| x.visible = true unless x.visible}
      [@enemy_groups, @monster_window].each {|x| x.visible = false if x.visible}
      @enemy_groups.active = false
    end
    # Atualiza a Animação do Inimigo
    @counting_frame += 1
    if @counting_frame == 8
      @counting_frame = 0
      @frame += 1
      @frame = 0 if @frame == 4
      if @phase == 0
        @monster_window.refresh(@enemy_groups.index, @pose, @frame)
      else
        enemy_id = @enemies[@groups_enemies.index].id
        @enemy_window.refresh(enemy_id, @pose, @frame)
      end
    end
    # Atualização da Fase atual
    case @phase
      when 0; main_update
      when 1; enemy_select
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização principal de quadros (frames)
  #--------------------------------------------------------------------------
  def main_update
    # Siar da Scena
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $game_temp.beastairy_return = false
      $scene = Scene_Map.new
    # Selecionar o Inimigo
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      if @enemy_groups.index == $game_beastairy.monster_groups.size
        $game_temp.beastairy_return = false
        $scene = Scene_Map.new
      else
        commands, @enemies = [], []
        group = $game_beastairy.monster_groups[@enemy_groups.index]
        for i in 1...$data_enemies.size
           if $data_enemies[i].group == group
            commands.push($data_enemies[i].name)
            @enemies.push($data_enemies[i])
          end
        end
        @groups_enemies = Window_Command.new(200, commands)
          @groups_enemies.y = 64
          @groups_enemies.height = 224
        # Atualização da Fase do Menu
        @phase_window.contents.clear
        @phase_window.contents.draw_text(0, 0, 168, 32, "Inimigo Selecionado", 1)
        # Soma Objeto (Por Atualizar)
        @objects.push(@groups_enemies)
        # Atualiza Janela de Controles
        @controls.refresh(1)
        enemy_id = @enemies[@groups_enemies.index].id
        @enemy_window.refresh(enemy_id, @pose, @frame)
        # Muda de Fase
        @phase = 1
      end
    # Muda de Poses
    elsif Input.trigger?(Input::LEFT)
      $game_system.se_play($data_system.cursor_se)
      @pose == 0 ? @pose = 3 : @pose -= 1
    elsif Input.trigger?(Input::RIGHT)
      $game_system.se_play($data_system.cursor_se)
      @pose == 3 ? @pose = 0 : @pose += 1
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização dos Quadros(Frame) do inmigo
  #--------------------------------------------------------------------------
  def enemy_select
    # Sair da Fase
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @groups_enemies.dispose
      @objects.delete(@groups_enemies)
      # Atualização da Janela de Fases
      @phase_window.contents.clear
      @phase_window.contents.draw_text(0, 0, 168, 32, "Menu Principal", 1)
      # Atualiza Janela dos controles
      @controls.refresh(0)
      # Muda de Fase
      @phase = 0
    # Inimigo Selecionado
    elsif Input.trigger?(Input::C)
      enemy  = @enemies[@groups_enemies.index]
      if enemy.seen
        $game_system.se_play($data_system.decision_se)
        enemy_name = enemy.name
        for i in 1...$data_troops.size
          if $data_troops[i].name == enemy_name
            $game_temp.beastairy_return = true
            $game_temp.battle_troop_id = i
            $game_temp.battle_can_escape = true
            $game_temp.battle_can_lose = false
            $game_temp.battle_proc = nil
            # Memorize mapa BGM e para BGM
            $game_temp.map_bgm = $game_system.playing_bgm
            $game_system.bgm_stop
            # Toca SE (batalha começada)
            $game_system.se_play($data_system.battle_start_se)
            # Toca BGM da batalha
            $game_system.bgm_play($game_system.battle_bgm)
            # Arruma posição do jogador
            $game_player.straighten
            # Ativa Tela de Batalha
            $scene = Scene_Battle.new
          end
        end
      else
        $game_system.se_play($data_system.buzzer_se)
      end
    elsif Input.trigger?(Input::LEFT)
      $game_system.se_play($data_system.cursor_se)
      @pose == 0 ? @pose = 3 : @pose -= 1
    elsif Input.trigger?(Input::RIGHT)
      $game_system.se_play($data_system.cursor_se)
      @pose == 3 ? @pose = 0 : @pose += 1
    end
  end
end

#==============================================================================
# ** Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Alias Processo Principal
  #--------------------------------------------------------------------------
  alias beastairy_main main
  #--------------------------------------------------------------------------
  # * Main Processo
  #--------------------------------------------------------------------------
  def main
    unless $game_temp.beastairy_return
      @beastairy_troop = []
      troop = $data_troops[$game_temp.battle_troop_id]
      for i in 0...troop.members.size
        enemy = $data_enemies[troop.members[i].enemy_id]
        @beastairy_troop.push(enemy)
        enemy.see
      end
    else
      @beastairy_troop = []
    end
    beastairy_main
  end
  #--------------------------------------------------------------------------
  # * Batalha Terminada
  #     result : resultado (0:ganhou 1:perdeu 2:escapau)
  #--------------------------------------------------------------------------
  def battle_end(result)
    # Limpa bandeira de Batalha
    $game_temp.in_battle = false
    # Limpa todo o grupo de açaõ
    $game_party.clear_actions
    # Remove Status da Batalha
    for actor in $game_party.actors
      actor.remove_states_battle
    end
    # Limpa Inimigos
    $game_troop.enemies.clear
    # Chama a Volta da BAtalha
    if $game_temp.battle_proc != nil
      $game_temp.battle_proc.call(result)
      $game_temp.battle_proc = nil
    end
    if $game_temp.beastairy_return
      $scene = Scene_Beastairy.new
    else
      if result == 0
        for enemy in @beastairy_troop
          enemy.defeat
        end
      end
      $scene = Scene_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização de Quadros (Frames)
  #--------------------------------------------------------------------------
  def update
    # Se Fugiu na batalha
    if $game_system.battle_interpreter.running?
      # Atualiza interpretador
      $game_system.battle_interpreter.update
      # Se um battler que está forçando ações não existe
      if $game_temp.forcing_battler == nil
        # Se evento de batalha terminou
        unless $game_system.battle_interpreter.running?
          # Retorna ao Evento de Batalha se a batalha continua
          unless judge
            setup_battle_event
          end
        end
        # Se não depois da fase da batalha 
        if @phase != 5
          # Atualiza a Janela de Status
          @status_window.refresh
        end
      end
    end
    # Atualiza sistema e tela
    $game_system.update
    $game_screen.update
    # Se cronômetro alcançou 0
    if $game_system.timer_working and $game_system.timer == 0
      # Cancela a Batalha
      $game_temp.battle_abort = true
    end
    # Atualiza Janelas
    @help_window.update
    @party_command_window.update
    @actor_command_window.update
    @status_window.update
    @message_window.update
    # Atualiza setagem do personagem
    @spriteset.update
    # Se é processada a transition
    if $game_temp.transition_processing
      # Limpa o processo de transition
      $game_temp.transition_processing = false
      # Executa a transition
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    # Se a mensagem for mostrada / Janela
    if $game_temp.message_window_showing
      return
    end
    # Se o Efeito for mostrado
    if @spriteset.effect?
      return
    end
    # Se for game over
    if $game_temp.gameover
      # Liga Tela de Game Over
      if $game_temp.beastairy_return
        $scene = Scene_Beastairy.new
      else
        $scene = Scene_Gameover.new
      end
    end
    # Se retorna a Tela de Titulo
    if $game_temp.to_title
      # Liga Tela de Titulo
      $scene = Scene_Title.new
      return
    end
    # Se a batalha for cancelada
    if $game_temp.battle_abort
      # Retorna para a BGM que foi usado antes da batalha
      $game_system.bgm_play($game_temp.map_bgm)
      # Terminou a Batalha
      battle_end(1)
      return
    end
    # Se esperou
    if @wait_count > 0
      # Diminui a Contagem de esperar
      @wait_count -= 1
      return
    end
    # Se batatalha força uma ação não inexistente,
    # e o evento de batalha foge
    if $game_temp.forcing_battler == nil and
       $game_system.battle_interpreter.running?
      return
    end
    # Se ramifique de acordo com fase
    case @phase
    when 1  # Fase Antes da Batalha
      update_phase1
    when 2  # Fase de Comando do Grupo
      update_phase2
    when 3  # Fase do comando do personagem
      update_phase3
    when 4  # Fase Principal
      update_phase4
    when 5  # Depois da fase da batalha
      update_phase5
    end
  end  
  #--------------------------------------------------------------------------
  # * Depois da Fase da Batalha
  #--------------------------------------------------------------------------
  def start_phase5
    # Shift para fase 5
    @phase = 5
    # Batalha de jogo mE termina
    $game_system.me_play($game_system.battle_end_me)
    # Retorna a BGM de antes da batalha
    $game_system.bgm_play($game_temp.map_bgm)
    # Inizializa EXP, aumenta o gold, e o tresouro
    exp = 0
    gold = 0
    treasures = []
    # Loop
    for enemy in $game_troop.enemies
      # Se o inimigo não é escondido
      unless enemy.hidden
        unless $game_temp.beastairy_return
          # Soma EXP e a quantia de ouro obtidas
          exp += enemy.exp
          gold += enemy.gold
          # Determine se tesouro apareceu
          if rand(100) < enemy.treasure_prob
            if enemy.item_id > 0
              treasures.push($data_items[enemy.item_id])
            end
            if enemy.weapon_id > 0
              treasures.push($data_weapons[enemy.weapon_id])
            end
            if enemy.armor_id > 0
              treasures.push($data_armors[enemy.armor_id])
            end
          end
        end
      end
    end
    # Tesouro é limitado a um máximo de 6 artigos
    treasures = treasures[0..5]
    # Obtem EXP
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      if actor.cant_get_exp? == false
        last_level = actor.level
        actor.exp += exp
        if actor.level > last_level
          @status_window.level_up(i)
        end
      end
    end
    # Obtem Gold
    $game_party.gain_gold(gold)
    # Obtem Tesouro
    for item in treasures
      case item
      when RPG::Item
        $game_party.gain_item(item.id, 1)
      when RPG::Weapon
        $game_party.gain_weapon(item.id, 1)
      when RPG::Armor
        $game_party.gain_armor(item.id, 1)
      end
    end
    # Faz a janela do resultado da batalha
    @result_window = Window_BattleResult.new(exp, gold, treasures)
    # Espera a contagem
    @phase5_wait_count = 100
  end
end