#############################################################################
# Castlevania SOTN Menu Versão XP 1.0 by Alucard_2                          #
#############################################################################
# Cole-o acima do main.                                                    #
#############################################################################
# Créditos totalmente para: Alucard_2! Favor avisar-me e dar-me        #
# créditos quando colocá-lo em algum lugar!                                #
#############################################################################
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
#x Configurações xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
module CTV
  #x Opções do menu x#
  Familliars = "    Familiars" # Familiares/Ajudantes
  Save_Game = "    Salvar Jogo" # Salvar Jogo
  Game_End = "    Fim de Jogo" # Fim de Jogo
  #x Vocabulário x#
  EXP = "EXP" # Experiência Total
  NEXT = "NEXT" # Esperiência necessária para o próximo nível
end
#==============================================================================
# Scene_Menu
#------------------------------------------------------------------------------
class Scene_Menu
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #    menu_index : posição inicial do cursor de comando
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  # Processamento Principal
  def main
    # Criar janela de comando
    s1 = $data_system.words.equip
    s2 = $data_system.words.skill
    s3 = $data_system.words.item
    s4 = (CTV::Familliars)
    s5 = (CTV::Save_Game)
    s6 = (CTV::Game_End)
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
    @command_window.index = @menu_index
    @command_window.x = 250
    @command_window.y = 150
    # Se o número de membros do Grupo de Heróis for 0
    if $game_party.actors.size == 0
      # Desabilitar as janelas de Item, Habilidades, Equipamento e Status
      @command_window.disable_item(0)
      @command_window.disable_item(1)
      @command_window.disable_item(2)
      @command_window.disable_item(3)
    end
    # Se Salvar for Proibido
    if $game_system.save_disabled
      # Desabilitar Salvar
      @command_window.disable_item(4)
    end
    # Criar janela de Tempo de Jogo
    @playtime_window = Window_PlayTime.new
    @playtime_window.x = 450
    @playtime_window.y = 400
    @playtime_window.z = 1
    # Criar janela de Número Passos
    @steps_window = Window_Steps.new
    @steps_window.x = 400
    @steps_window.y = 320
    @steps_window.z = 1
    # Criar janela de Dinheiro
    @gold_window = Window_Gold.new
    @gold_window.x = 0
    @gold_window.y = 416
    @gold_window.z = 1
    # Criar janela de Status
    @status_window = Window_CTVStatus.new
    @status_window.x = 0
    @status_window.y = 0
    @status_window.z = 1
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar Frame
      update
      # Abortar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para transiçõa
    Graphics.freeze
    # Exibição das janelas
    @command_window.dispose
    @playtime_window.dispose
    @steps_window.dispose
    @gold_window.dispose
    @status_window.dispose
  end
  # Atualização do Frame
  def update
    # Atualizar janelas
    @command_window.update
    @playtime_window.update
    @steps_window.update
    @gold_window.update
    @status_window.update
    # Se a janela de comandos estiver ativo: chamar update_command
    if @command_window.active
      update_command
      return
    end
    # Se a janela de Status estiver ativa: call update_status
    if @status_window.active
      update_status
      return
    end
  end
  # Atualização do Frame (Quando a janela de Comandos estiver Ativa)
  def update_command
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela do mapa
      $scene = Scene_Map.new
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Se o comando for outro senão Salvar, Fim de Jogo e o número de Heróis no
      # Grupo for 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Ramificação por posição do cursor na janela de comandos
      case @command_window.index
      when 0  # Equipamentos
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Itens
        $scene = Scene_Equip.new
      when 1  # Habilidades
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Ativar o status da janela
        $scene = Scene_Skill.new
      when 2  # Itens
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Ativar o status da janela
        $scene = Scene_Item.new
      when 3  # Status
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Ativar o status da janela
        $scene = Scene_Familliars.new
      when 4  # Salvar
        # Se Salvar for proibido
        if $game_system.save_disabled
          # Reproduzir SE de erro
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de save
        $scene = Scene_Save.new
      when 5  # Fim de Jogo
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Fim de Jogo
        $scene = Scene_End.new
      end
      return
    end
  end
  # Atualização do Frame (Quando o status da Janela estiver Ativo)
  def update_status
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Torna a janela de comandos ativa
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Ramificação por posição do cursor na janela de comandos
      case @command_window.index
      when 1  # Habilidades
        # Se o limite de ação deste Herói for de 2 ou mais
        if $game_party.actors[@status_window.index].restriction >= 2
          # Reproduzir SE de erro
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Habilidades
        $scene = Scene_Skill.new(@status_window.index)
      when 2  # Equipamento
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Equipamento
        $scene = Scene_Equip.new(@status_window.index)
      when 3  # Status
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Status
        $scene = Scene_Status.new(@status_window.index)
      end
      return
    end
  end
end
#==============================================================================
# Scene_Equip
#==============================================================================
class Scene_Equip
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #    actor_index : Índice de Heróis
  #    equip_index : Índice de Equipamentos
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
    @equip_index = equip_index
  end
  # Processamento Principal
  def main
    # Selecionar Herói
    @actor = $game_party.actors[@actor_index]
    # Criar janelas
    @help_window = Window_Help.new
    @help_window.y = 416
    @left_window = Window_EquipLeft.new(@actor)
    @left_window.y = 0
    @right_window = Window_EquipRight.new(@actor)
    @right_window.y = 0
    @item_window1 = Window_EquipItem.new(@actor, 0)
    @item_window2 = Window_EquipItem.new(@actor, 1)
    @item_window3 = Window_EquipItem.new(@actor, 2)
    @item_window4 = Window_EquipItem.new(@actor, 3)
    @item_window5 = Window_EquipItem.new(@actor, 4)
    @item_window1.y = 192
    # Associar a janela de ajuda
    @right_window.help_window = @help_window
    @item_window1.help_window = @help_window
    @item_window2.help_window = @help_window
    @item_window3.help_window = @help_window
    @item_window4.help_window = @help_window
    @item_window5.help_window = @help_window
    # Definir a posição do cursor
    @right_window.index = @equip_index
    refresh
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar o frame
      update
      # Abortar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para a transição
    Graphics.freeze
    # Exibição das janelas
    @help_window.dispose
    @left_window.dispose
    @right_window.dispose
    @item_window1.dispose
    @item_window2.dispose
    @item_window3.dispose
    @item_window4.dispose
    @item_window5.dispose
  end
  # Atualizar
  def refresh
    # Definir a janela de Itens como visível
    @item_window1.visible = (@right_window.index == 0)
    @item_window2.visible = (@right_window.index == 1)
    @item_window3.visible = (@right_window.index == 2)
    @item_window4.visible = (@right_window.index == 3)
    @item_window5.visible = (@right_window.index == 4)
    # Selecionar os ´tens equipados atualmente
    item1 = @right_window.item
    # Set current item window to @item_window
    case @right_window.index
    when 0
      @item_window = @item_window1
    when 1
      @item_window = @item_window2
    when 2
      @item_window = @item_window3
    when 3
      @item_window = @item_window4
    when 4
      @item_window = @item_window5
    end
    # Se a janela da direita estiver ativa
    if @right_window.active
      # Limpar parâmetros para depois fazer a troca de equipamentos
      @left_window.set_new_parameters(nil, nil, nil)
    end
    # Se a janela de Itens estiver ativa
    if @item_window.active
      # Selecionar o Item escolhido
      item2 = @item_window.item
      # Mudar Equipamento
      last_hp = @actor.hp
      last_sp = @actor.sp
      @actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
      # Selecionar parâmetros para depois fazer a troca de equipamentos
      new_atk = @actor.atk
      new_pdef = @actor.pdef
      new_mdef = @actor.mdef
      # Retornar equipamento
      @actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
      @actor.hp = last_hp
      @actor.sp = last_sp
      # Desenhar na janela da esquerda
      @left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
    end
  end
  # Atualização do Frame
  def update
    # Atualizar janelas
    @left_window.update
    @right_window.update
    @item_window.update
    refresh
    # Se a janela da direita estiver ativa: chamar update_right
    if @right_window.active
      update_right
      return
    end
    # Se a janela de Itens estiver ativa: chamar update_item
    if @item_window.active
      update_item
      return
    end
  end
  # Atualização do Frame (Quando a janela da direita estiver Ativa)
  def update_right
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(0)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Se o equipamento for fixo
      if @actor.equip_fix?(@right_window.index)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Ativar janela de Itens
      @right_window.active = false
      @item_window.active = true
      @item_window.index = 0
      return
    end
    # Se o botão R for pressionado
    if Input.trigger?(Input::R)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O cursor se move para o próximo Herói
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de equipamento diferente
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
    # Se o botão L for precionado
    if Input.trigger?(Input::L)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O cursor se move para o Herói anterior
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de equipamento diferente
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
  end
  # Atualização do Frame (Quando a janela de Itens estiver Ativa)
  def update_item
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Ativar janela da direita
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Reproduzir SE de Equipamento
      $game_system.se_play($data_system.equip_se)
      # Selecionar dados escolhidos na janela de Item
      item = @item_window.item
      # Mudar Equipamento
      @actor.equip(@right_window.index, item == nil ? 0 : item.id)
      # Ativar janela da direita
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      # Recriar os conteúdos da janela de Itens e da direita
      @right_window.refresh
      @item_window.refresh
      return
    end
  end
end
#==============================================================================
# Scene_Skill
#==============================================================================
class Scene_Skill
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #    actor_index : Índice de Heróis
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
  end
  # Processamento Principal
  def main
    # Selecionar Herói
    @actor = $game_party.actors[@actor_index]
    # Criar janela de Ajuda, Status e Habilidades
    @help_window = Window_Help.new
    @help_window.y = 416
    @status_window = Window_SkillStatus.new(@actor)
    @status_window.y = 0
    @skill_window = Window_Skill.new(@actor)
    @skill_window.y = 64
    # Associar a janela de Ajuda
    @skill_window.help_window = @help_window
    # Criar janela alvo (definir como invisível / inativa)
    @target_window = Window_Target.new
    @target_window.visible = false
    @target_window.active = false
    # Executar transição
    Graphics.transition
    # Loop Principal
    loop do
      # Atualizar tela de Jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar frame
      update
      # Abortoar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para transição
    Graphics.freeze
    # Exibição das janelas
    @help_window.dispose
    @status_window.dispose
    @skill_window.dispose
    @target_window.dispose
  end
  # Atualização do Frame
  def update
    # Atualizar janelas
    @help_window.update
    @status_window.update
    @skill_window.update
    @target_window.update
    # Se a janela de Habilidades estiver ativa: chamar update_skill
    if @skill_window.active
      update_skill
      return
    end
    # Se a janela alvo estiver ativa: chamar update_target
    if @target_window.active
      update_target
      return
    end
  end
  # Atualização do Frame (Qunado a janela de Habilidades estiver ativa)
  def update_skill
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(1)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Selecionar dados escolhidos na janela de Habilidades
      @skill = @skill_window.skill
      # Aqui é verificado se é possível utilizar a Habilidade
      if @skill == nil or not @actor.skill_can_use?(@skill.id)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Se o efeito da Habilidade for um aliado
      if @skill.scope >= 3
        # Ativar janela alvo
        @skill_window.active = false
        @target_window.x = (@skill_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Definir se o alcance é um aliado ou todo o grupo
        if @skill.scope == 4 || @skill.scope == 6
          @target_window.index = -1
        elsif @skill.scope == 7
          @target_window.index = @actor_index - 10
        else
          @target_window.index = 0
        end
      # Se o efeito for outro senão para um aliado
      else
        # Se o ID do evento comum for válido
        if @skill.common_event_id > 0
          # Chamar evento comum da reserva
          $game_temp.common_event_id = @skill.common_event_id
          # Reproduzir SE da Habilidade
          $game_system.se_play(@skill.menu_se)
          # Descontar MP
          @actor.sp -= @skill.sp_cost
          # Recriar cada conteúdo das janelas
          @status_window.refresh
          @skill_window.refresh
          @target_window.refresh
          # Alternar para a tela do Mapa
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
    # Se o botão R for pressionado
    if Input.trigger?(Input::R)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao próximo Herói
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de Habilidades diferente
      $scene = Scene_Skill.new(@actor_index)
      return
    end
    # Se o botão L for pressionado
    if Input.trigger?(Input::L)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao Herói anterior
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de Habilidades diferente
      $scene = Scene_Skill.new(@actor_index)
      return
    end
  end
  # Atualização do Frame (Quando a janela alvo estiver ativa)
  def update_target
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Apagar janela alvo
      @skill_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Aqui é verificada a quantidade de MP a ser usada,
      # caso não seja suficiente
      unless @actor.skill_can_use?(@skill.id)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Se o alvo for todos os aliados
      if @target_window.index == -1
        # Aplicar os efeitos da Habilidade em todo o Grupo de Heróis
        used = false
        for i in $game_party.actors
          used |= i.skill_effect(@actor, @skill)
        end
      end
      # Se o alvo for o usuário
      if @target_window.index <= -2
        # Aplicar os efeitos da Habilidade em si mesmo
        target = $game_party.actors[@target_window.index + 10]
        used = target.skill_effect(@actor, @skill)
      end
      # Se o alvo for um aliado
      if @target_window.index >= 0
        # Aplicar os efeitos da Habilidade no Herói alvo
        target = $game_party.actors[@target_window.index]
        used = target.skill_effect(@actor, @skill)
      end
      # Se a Habilidade for utilizada
      if used
        # Reproduzir SE da Habilidade
        $game_system.se_play(@skill.menu_se)
        # Descontar o MP
        @actor.sp -= @skill.sp_cost
        # Recriar o conteúdo de cada janela
        @status_window.refresh
        @skill_window.refresh
        @target_window.refresh
        # Se todo o Grupo de Heróis estiver morto
        if $game_party.all_dead?
          # Alternar para a tela de Game Over
          $scene = Scene_Gameover.new
          return
        end
        # Se o ID do evento comum for válido
        if @skill.common_event_id > 0
          # Chamar evento comum da reserva
          $game_temp.common_event_id = @skill.common_event_id
          # Alternar para a tela do Mapa
          $scene = Scene_Map.new
          return
        end
      end
      # Se a Habilidade não foi usada
      unless used
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    end
  end
end
#==============================================================================
# Scene_Item
#==============================================================================
class Scene_Item
  # Processamento Principal
  def main
    # Aqui são criadas as janelas de Ajuda e de Itens
    @help_window = Window_Help.new
    @help_window.y = 416
    @item_window = Window_Item.new
    @item_window.y = 0
    # Associar a janela de Ajuda
    @item_window.help_window = @help_window
    # Criar janela alvo (definir como invisível / inativa)
    @target_window = Window_Target.new
    @target_window.visible = false
    @target_window.active = false
    @target_window.y = 0
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualização do frame
      update
      # Abortar o loop se a tela foi alterada
      if $scene != self
        break
      end
    end
    # Prepara para transição
    Graphics.freeze
    # Exibição das janelas
    @help_window.dispose
    @item_window.dispose
    @target_window.dispose
  end
  # Atualização do Frame
  def update
    # Atualizar janelas
    @help_window.update
    @item_window.update
    @target_window.update
    # Se a janela de Itens estiver ativa: chamar update_item
    if @item_window.active
      update_item
      return
    end
    # Se a janela alvo estiver ativa: chamar update_target
    if @target_window.active
      update_target
      return
    end
  end
  # Atualização do Frame (Quando a janela de Itens estiver Ativa)
  def update_item
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(2)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Selecionar os dados escolhidos na janela de Itens
      @item = @item_window.item
      # Se não for um Item usável
      unless @item.is_a?(RPG::Item)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Se não puder ser usado
      unless $game_party.item_can_use?(@item.id)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Se o alcance do Item for um aliado
      if @item.scope >= 3
        # Ativar a janela alvo
        @item_window.active = false
        @target_window.x = (@item_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Definir a posição do cursor no alvo (aliado / todo grupo)
        if @item.scope == 4 || @item.scope == 6
          @target_window.index = -1
        else
          @target_window.index = 0
        end
      # Se o alcance for outro senão um aliado
      else
        # Se o ID do evento comum for inválido
        if @item.common_event_id > 0
          # Chamar evento comum da reserva
          $game_temp.common_event_id = @item.common_event_id
          # Reproduzir SE do Item
          $game_system.se_play(@item.menu_se)
          # Se for consumível
          if @item.consumable
            # Diminui 1 Item da quantidade total
            $game_party.lose_item(@item.id, 1)
            # Desenhar o Item
            @item_window.draw_item(@item_window.index)
          end
          # Alternar para a tela do Mapa
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
  end
  # Atualização do Frame (Quando a janela alvo estiver Ativa)
  def update_target
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Se for impossível utilizar porque o Item não existe mais
      unless $game_party.item_can_use?(@item.id)
        # Recriar os conteúdos da janela de ìtens
        @item_window.refresh
      end
      # Apagar a janela alvo
      @item_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Se chegar ao número 0 da quantidade de Itens
      if $game_party.item_number(@item.id) == 0
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Se o alvo for todos o Grupo
      if @target_window.index == -1
        # Os efeitos serão aplicados a todos
        used = false
        for i in $game_party.actors
          used |= i.item_effect(@item)
        end
      end
      # Se for apenas um aliado o alvo
      if @target_window.index >= 0
        # Aplicar os efeitos apenas no Herói alvo
        target = $game_party.actors[@target_window.index]
        used = target.item_effect(@item)
      end
      # Se o Item for usado
      if used
        # Reproduzir SE do Item
        $game_system.se_play(@item.menu_se)
        # Se for consumível
        if @item.consumable
          # Diminui 1 item da quantidade total
          $game_party.lose_item(@item.id, 1)
          # Redesenhar o Item
          @item_window.draw_item(@item_window.index)
        end
        # Recriar os conteúdos da janela alvo
        @target_window.refresh
        # Se todos no Grupo de Heróis estiverm mortos
        if $game_party.all_dead?
          # Alternar para a tela de Game Over
          $scene = Scene_Gameover.new
          return
        end
        # Se o ID do evento comum for válido
        if @item.common_event_id > 0
          # Chamar o evento comum da reserva
          $game_temp.common_event_id = @item.common_event_id
          # Alternar para a tela do Mapa
          $scene = Scene_Map.new
          return
        end
      end
      # Se o Item não for usado
      unless used
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    end
  end
end
#==============================================================================
# Scene_Familliars
#==============================================================================
class Scene_Familliars
  # Processamento Principal
  def main
    # Criar a janela de Status
    @status_window = Window_CTVFamilliars.new
    # Executar Transição
    Graphics.transition
    # Loop principal
    loop do
      # Aqui a tela é atualizada
      Graphics.update
      # E os dados também
      Input.update
      # Então os frames são atualizados
      update
      # Abortar loop se a janela for alterada
      if $scene != self
        break
      end
    end
    # preparar para transição
    Graphics.freeze
    # E a janela é exibida
    @status_window.dispose
  end
  # Atualização do frame
  def update
    # Caso o botão B seja pressionado
    if Input.trigger?(Input::B)
      # É tocada a música SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Mudar para a tela do Menu
      $scene = Scene_Menu.new(3)
      return
    end
  end
end
#----------------------------------------------------------------------------
# Window_CTVFamilliars
#----------------------------------------------------------------------------
# Esta classe é responsável por mostrar os atributos dos outros heróis.
#----------------------------------------------------------------------------
class Window_CTVFamilliars < Window_Base
  # Inicialização dos Objetos
  def initialize
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    refresh
  end
  # Atualização
  def refresh
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(250, 5, 640, 32, "Familiares")
    @item_max = 1
      unless $game_party.actors[1] == nil
        x = 0
        y = 30
        actor = $game_party.actors[1]
        draw_actor_graphic(actor, x + 30, y + 82)
        draw_actor_name(actor, x + 80, y + 30)
        draw_actor_level(actor, x + 80, y + 50)
        draw_actor_state(actor, x + 75, y + 72)
        self.contents.font.color = system_color
        self.contents.draw_text(150, y + 50, 80, 32, (CTV::EXP))
        self.contents.draw_text(150, y + 72, 80, 32, (CTV::NEXT))
        self.contents.font.color = normal_color
        self.contents.draw_text(150 + 80, y + 50, 84, 32, actor.exp_s, 2)
        self.contents.draw_text(150 + 80, y + 72, 84, 32, actor.next_rest_exp_s, 2)
      end
      unless $game_party.actors[2] == nil
        x = 0
        y = 130
        actor = $game_party.actors[2]
        draw_actor_graphic(actor, x + 30, y + 82)
        draw_actor_name(actor, x + 80, y + 30)
        draw_actor_level(actor, x + 80, y + 50)
        draw_actor_state(actor, x + 75, y + 72)
        self.contents.font.color = system_color
        self.contents.draw_text(150, y + 50, 80, 32, (CTV::EXP))
        self.contents.draw_text(150, y + 72, 80, 32, (CTV::NEXT))
        self.contents.font.color = normal_color
        self.contents.draw_text(150 + 80, y + 50, 84, 32, actor.exp_s, 2)
        self.contents.draw_text(150 + 80, y + 72, 84, 32, actor.next_rest_exp_s, 2)
      end     
      unless $game_party.actors[3] == nil
        x = 320
        y = 30
        actor = $game_party.actors[3]
        draw_actor_graphic(actor, x + 30, y + 82)
        draw_actor_name(actor, x + 80, y + 30)
        draw_actor_level(actor, x + 80, y + 50)
        draw_actor_state(actor, x + 75, y + 72)
        self.contents.font.color = system_color
        self.contents.draw_text(x + 150, y + 50, 80, 32, (CTV::EXP))
        self.contents.draw_text(x + 150, y + 72, 80, 32, (CTV::NEXT))
        self.contents.font.color = normal_color
        self.contents.draw_text(x + 200, y + 50, 84, 32, actor.exp_s, 2)
        self.contents.draw_text(x + 200, y + 72, 84, 32, actor.next_rest_exp_s, 2)
      end
    end
  end
  # Renovação do Retângulo de Seleção
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
    else
      self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
    end
  end
#----------------------------------------------------------------------------
# Window_CTVStatus
#----------------------------------------------------------------------------
# Esta classe é responsável por mostrar todos os atributos do herói principal.
#----------------------------------------------------------------------------
class Window_CTVStatus < Window_Selectable
  # Inicialização dos Objetos
  def initialize
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    refresh
    self.active = false
    self.index = -1
  end
  # Atualização
  def refresh
    self.contents.clear
    @item_max = 1
      x = 40
      y = 5
      actor = $game_party.actors[0]
      draw_actor_graphic(actor, x + 60, y + 80)
      draw_actor_name(actor, x + 120, y)
      draw_actor_level(actor, x + 450, y + 50)
      draw_actor_state(actor, x + 90, y + 32)
      draw_actor_hp(actor, x + 236, y + 32)
      draw_actor_sp(actor, x + 236, y + 62)
      draw_actor_parameter(actor, 10, 270, 2)
      draw_actor_parameter(actor, 10, 142, 3)
      draw_actor_parameter(actor, 420, 156, 0)
      draw_actor_parameter(actor, 420, 178, 1)
      draw_actor_parameter(actor, 10, 206, 4)
      draw_actor_parameter(actor, 10, 238, 5)
      draw_actor_parameter(actor, 10, 174, 6)
      self.contents.font.color = system_color
      self.contents.draw_text(5, 360, 80, 32, (CTV::EXP))
      self.contents.draw_text(5, 386, 80, 32, (CTV::NEXT))
      self.contents.font.color = normal_color
      self.contents.draw_text(5 + 80, 360, 84, 32, actor.exp_s, 2)
      self.contents.draw_text(5 + 80, 386, 84, 32, actor.next_rest_exp_s, 2)
    end
  end
  # Renovação do Retângulo de Seleção
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
    else
      self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
    end
  end
  def create_menu_commands
end
#==============================================================================
# Window_Item
#==============================================================================
class Window_Item < Window_Selectable
  # Inicialização dos Objetos
  def initialize
    super(0, 0, 640, 416)
    @column_max = 2
    refresh
    self.index = 0
    # Caso se está em uma batalha a janela será movida para o centro da tela
    # e esta é transformada em semi-transparente
    if $game_temp.in_battle
      self.y = 64
      self.height = 256
      self.back_opacity = 160
    end
  end
  # Selecionar Item
  def item
    return @data[self.index]
  end
  # Atualização
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Adicionar Item
    for i in 1...$data_items.size
      if $game_party.item_number(i) > 0
        @data.push($data_items[i])
      end
    end
    # Também é adicionados os equipamentos e os Itens chave caso se esteja fora
    # de uma batalha
    unless $game_temp.in_battle
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0
          @data.push($data_weapons[i])
        end
      end
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0
          @data.push($data_armors[i])
        end
      end
    end
    # Caso haja algum Item aqui a janela é desenhada, junto com todos os Itens
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # Desenhar Item
  #
  #    index : índice de Itens
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    end
    if item.is_a?(RPG::Item) and
      $game_party.item_can_use?(item.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
  # Atualização do Texto de Ajuda
  def update_help
    @help_window.set_text(self.item == nil ? "" : self.item.description)
  end
end