[VX]Menu objet classe qui fait(presque)tout.

#==============================================================================
# Scene ItemPlus [VX]
#------------------------------------------------------------------------------
# Modifica totalmente o sistema de menu de itens padrão do RPG Maker VX.
#------------------------------------------------------------------------------
# Autor: Kyo Panda (http://www.mundorpgmaker.com/)
# Lançado em: 26/04/2010
# Versão: 1.2
# Atualização: 19/05/2010
#==============================================================================

#==============================================================================
# Agradecimentos:
#------------------------------------------------------------------------------
# * kalormano (http://www.mundorpgmaker.com/)
#  Por encontrar o bug do drop de itens.
# * kako92 (http://www.mundorpgmaker.com/)
#  Por encontrar o bug de quando os itens eram utilizados até o fim.
#==============================================================================

#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# * Lhe dá a opção de mudar a visualização de itens para ícones.
# * Permite que você selecione quantos ícones de itens deve haver por colunas.
# * Permite selecionar a visualização dos itens selecionando-os pelo seu tipo.
# * Permite que você equipe equipamentos pelo menu de itens, se desejar.
# * Lhe dá a opção de verificar as propriedades básicas do ítem simplesmente
#  segurando a tecla SHIFT.
# * Permite que você oculte as janelas, permitindo assim você colocar uma
#  imagem de fundo na forma do menu.
# * Permite que você configure todos os textos, assim como janelas e suas
#  posições e tamanhos, do script.
#==============================================================================

#==============================================================================
# Histórico de versões;
#------------------------------------------------------------------------------
# Versão 1.2, 19/05/2010:
# * Corrigido o bug do drop de itens.
# * Corrigido o bug de quando os itens eram utilizados até o fim.
# Versão 1.1, 26/04/2010:
# * Adicionado a permição de optar entre usar ou não a função de "equipar pelo
#  menu de itens.
# * Adicionado a opção de definir os nomes e a ordem em que as opções da
#  janela de "Usar ítem" são exibidos, assim como os nomes e a ordem da
#  "Janela de seleção do modo de exibição dos itens".
# * Adicionado as "Configurações Avançadas", assim como a opção de modificar
#  todas as strings do script.
# Versão 1.0, 25/04/2010
# * Primeira versão do script.
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação
# #--------------------------------------------------------------------------
#
# Cole o script do menu acima do "▼ Principal" e abaixo dos
# "▼ Scripts Adicionais" no Editor de Scripts do RPG Maker VX.
#
# Configure o script como desejar no guia "Configuração" logo abaixo.
#==============================================================================

#==============================================================================
# Scene_ItemPlus
#------------------------------------------------------------------------------
# Módulo de configuração do menu de itens.
#==============================================================================

module Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Configuração
  #--------------------------------------------------------------------------
 
  # Defina aqui o modo de exibição dos itens na tela do menu.
  # 0: Somente será exibido os ícones com suas quantidades no lado inferior
  #    esquerdo. Seus nomes serão exibidos antes de suas definições na janela
  #    de ajuda.
  # 1: Modo clássico do RPG Maker VX. Serão exibidos os ícones com seus nomes
  #    logo ao lado e suas quantidades ao lado do nome.
  ITEM_MENU_MODE = 0
 
  # Se caso você escolheu o modo de exibição de itens 0, defina aqui quantos
  # ícones por coluna você deseja.
  COLUMN_NUMBER = 12
 
  # Defina aqui a opacidade (transparência) das janelas da tela de itens.
  # Esta opção é útil caso queira utilizar uma imagem de fundo em vez das
  # janelas.
  # 0: Transparente; 255: Opaco.
  ITEM_MENU_OPACITY = 255
 
  # Defina aqui a imagem de background do menu.
  # O arquivo deve estar na pasta Graphics/System.
  # O nome do arquivo deve estar entre aspas ("") ou apóstrofes ('').
  # Defina como nil para manter o plano de fundo padrão.
  ITEM_MENU_BACK = nil # "Item Menu Background"
 
  # Defina aqui o aspecto da fonte na tela de itens.
  # A fonte é definida por ordem de prioridade, logo se a primeira não
  # existir ele procurará a segunda e assim por diante.
  ITEM_MENU_FONT = ["UmePlus Gothic", "Calibri"] # Nome da fonte
 
  # Defina aqui o número de colunas existentes para a janela de visualização
  # de itens.
  ITEM_VISUAL_COLUMNS = 6
 
  # Defina aqui os ícones da janela de seleção do modo de exibição da tela
  # de itens.
  ITEM_ICON_ALL_ITEMS  = 133 # Todos
  ITEM_ICON_ITEMS      = 144 # Ítens
  ITEM_ICON_WEAPONS    = 2  # Armas
  ITEM_ICON_ARMORS      = 40  # Armaduras
  ITEM_ICON_ACCESSORIES = 32  # Acessórios
  ITEM_ICON_VALUABLES  = 145 # Valiosos
 
  # Defina aqui os textos que serão exibidos no guia de ajuda do modo de
  # seleção de itens.
  # Os nomes deve estar entre aspas ("") ou apóstrofes ('') para serem
  # considerados textos pelo RPG Maker VX.
  ITEM_HELP_ALL_ITEMS  = "Todos"      # Todos
  ITEM_HELP_ITEMS      = "Ítens"      # Ítens
  ITEM_HELP_WEAPONS    = "Armas"      # Armas
  ITEM_HELP_ARMORS      = "Armaduras"  # Armaduras
  ITEM_HELP_ACCESSORIES = "Acessórios" # Acessórios
  ITEM_HELP_VALUABLES  = "Valiosos"  # Valiosos
 
  # Defina aqui a ordem em que os modos de visualização serão exibidos.
  # Lembre-se que a primeira opção é 0 e segue a ordem as demais.
  ITEM_INDEX_ALL_ITEMS  = 0 # Todos
  ITEM_INDEX_ITEMS      = 1 # Ítens
  ITEM_INDEX_WEAPONS    = 2 # Armas
  ITEM_INDEX_ARMORS      = 3 # Armaduras
  ITEM_INDEX_ACCESSORIES = 4 # Acessórios
  ITEM_INDEX_VALUABLES  = 5 # Valiosos
 
  # Defina aqui a quantidade de modos de exibição que haverá disponível.
  # O padrão é 6, logo se você definir acima disso, nada ocorrerá com a 7ª
  # opção em diante. Mas, se você optar por um número menor, uma das opções
  # ou mais não funcionarão (caso você queira menos modos de visualização).
  # Então, se você escolher 5 opções, defina os indexes acima de 0 à 4
  # logo o index 5 será descartado.
  ITEM_VISUAL_NUMBER = 6
 
  # Defina aqui se deseja ativar o recurso "Equipar" pelo menu de itens.
  # Se você optar por NÃO utilizar a opção de "Equipar" pelo menu de itens,
  # ao invés de ser exibido a opção "Equipar" na janela de "Usar ítem",
  # será exibido a opção "Usar" em cinza, mostrando que o "Equipamento" não
  # pode ser usado.
  # Defina true para sim e false para não.
  ITEM_EQUIP_ACTIVE = true
 
  # Defina aqui as strings (textos) que serão exibidos em cada opção da
  # janela de "Usar item".
  # Os nomes deve estar entre aspas ("") ou apóstrofes ('') para serem
  # considerados textos pelo RPG Maker VX.
  ITEM_USE_NAME    = "Usar"      # Usar
  ITEM_EQUIP_NAME  = "Equipar"  # Equipar
  ITEM_VERIFY_NAME = "Verificar" # Verificar
  ITEM_DROP_NAME  = "Largar"    # Largar
 
  # Defina aqui a ordem em que as opções do "Usar item" serão exibidas.
  # O primeiro item deve ser definido como 0.
  ITEM_USE_INDEX    = 0 # Usar/Equipar
  ITEM_VERIFY_INDEX = 1 # Verificar
  ITEM_DROP_INDEX  = 2 # Largar
 
  # Defina aqui quais os textos exibidos quando a opção "Largar" é acionada.
  # Os nomes deve estar entre aspas ("") ou apóstrofes ('') para serem
  # considerados textos pelo RPG Maker VX.
  ITEM_DROP_QUESTION = "Tem certeza que deseja jogá-lo(s) fora?" # Pergunta
  ITEM_DROP_ANSWER1  = "Sim" # Resposta afirmativa
  ITEM_DROP_ANSWER2  = "Não" # Resposta negativa
 
  # Defina aqui quais os textos exibidos para itens ao utilizar a opção
  # "Verificar".
  # Os nomes deve estar entre aspas ("") ou apóstrofes ('') para serem
  # considerados textos pelo RPG Maker VX.
  ITEM_VERIFY_TEXT0 = "Usável em batalha e menu"  # Útil em batalha e menu
  ITEM_VERIFY_TEXT1 = "Usável somente em batalha" # Útil somente em batalha
  ITEM_VERIFY_TEXT2 = "Usável somente em menu"    # Útil somente em menu
  ITEM_VERIFY_TEXT3 = "Não usável"                # Não útil
 
  #--------------------------------------------------------------------------
  # Configurações avançadas
  #--------------------------------------------------------------------------
 
  # À partir daqui serão definidos valores substanciais ao funcionamento
  # do script, que são x (alinhamento horizontal), y (alinhamento vertical),
  # altura e largura de cada janela. Além de ser possível ocultar algumas
  # delas.
 
  # Aqui você pode definir se algumas janelas serão ativadas ou não.
  MNWA = true # Janela do nome do menu
  MGWA = true # Janela de dinheiro
  HPWA = true # Janela de ajuda sobre os itens
  MHWA = true # Janela de ajuda sobre a seleção do modo
 
  # Se utilizar o nome do menu, defina aqui qual nome ele deve apresentar.
  # Os nomes deve estar entre aspas ("") ou apóstrofes ('') para serem
  # considerados textos pelo RPG Maker VX.
  MENU_NAME = "Itens"
 
  # Defina aqui os valores estruturais de cada janela, que são x, y, largura
  # altura.
  #      [ X ,  Y , Lar, Alt]
  MNWV = [  0,  0, 200,  56] # Janela com o nome do menu
  MGWV = [344,  0, 200,  56] # Janela de dinheiro
  HPWV = [  0,  56, 544,  56] # Janela de ajuda sobre os itens
  MMWV = [  0, 112, 224,  56] # Janela de seleção do modo de visualização
  MHWV = [224, 112, 320,  56] # Janela de ajuda sobre a seleção do modo
  MIWV = [  0, 168, 544, 248] # Janela de itens
 
  #--------------------------------------------------------------------------
  # Fim da configuração
  #--------------------------------------------------------------------------
end

  #--------------------------------------------------------------------------
  # Insere a string "Scene_ItemPlus" na hash $kpanda_scripts
  #--------------------------------------------------------------------------
$kpanda_scripts = {} if $kpanda_scripts.nil?
$kpanda_scripts["Scene_ItemPlus"] = true

#==============================================================================
# Window_Equip
#------------------------------------------------------------------------------
# Janela que exibe os itens equipados no herói juntamente com a janela de
# itens possíveis de se equipar.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# * Novo método: item_max=.
#==============================================================================

class Window_Equip < Window_Selectable
  #--------------------------------------------------------------------------
  # Retorna o valor do item_max
  #--------------------------------------------------------------------------
  def item_max=(value)
    return @item_max = value
  end
end

#==============================================================================
# Window_ItemType
#------------------------------------------------------------------------------
# Janela de escolha do tipo de exibição da tela de itens.
#==============================================================================

class Window_ItemType < Window_Selectable
  #--------------------------------------------------------------------------
  # Inclusão das constantes do módulo Scene_ItemPlus
  #--------------------------------------------------------------------------
  include Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super(MMWV[0], MMWV[1], MMWV[2], MMWV[3])
    @index = 0
    @column_max = ITEM_VISUAL_COLUMNS
    @spacing = 0
    refresh
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for i in 1 .. ITEM_VISUAL_NUMBER
      @data.push(i)
    end
    @item_max = @data.size
    for i in 0 .. @item_max
      draw_item(i)
    end
  end
  #--------------------------------------------------------------------------
  # Desenho das opções
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    rect.width -= 4
    item_width = (self.width - 32) / @column_max
    align_m = (item_width - 24) / 2
    self.contents.clear_rect(rect)
    case index
    when ITEM_INDEX_ALL_ITEMS
      draw_icon(ITEM_ICON_ALL_ITEMS, rect.x + align_m, rect.y)
    when ITEM_INDEX_ITEMS
      draw_icon(ITEM_ICON_ITEMS, rect.x + align_m, rect.y)
    when ITEM_INDEX_WEAPONS
      draw_icon(ITEM_ICON_WEAPONS, rect.x + align_m, rect.y)
    when ITEM_INDEX_ARMORS
      draw_icon(ITEM_ICON_ARMORS, rect.x + align_m, rect.y)
    when ITEM_INDEX_ACCESSORIES
      draw_icon(ITEM_ICON_ACCESSORIES, rect.x + align_m, rect.y)
    when ITEM_INDEX_VALUABLES
      draw_icon(ITEM_ICON_VALUABLES, rect.x + align_m, rect.y)
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do texto na janela de ajuda
  #--------------------------------------------------------------------------
  def update_help
    @help_window.contents.font.name  = ITEM_MENU_FONT
    @help_window.contents.font.color = system_color
    if @index == ITEM_INDEX_ALL_ITEMS
      @help_window.set_text(ITEM_HELP_ALL_ITEMS, 1)
    elsif @index == ITEM_INDEX_ITEMS
      @help_window.set_text(ITEM_HELP_ITEMS, 1)
    elsif @index == ITEM_INDEX_WEAPONS
      @help_window.set_text(ITEM_HELP_WEAPONS, 1)
    elsif @index == ITEM_INDEX_ARMORS
      @help_window.set_text(ITEM_HELP_ARMORS, 1)
    elsif @index == ITEM_INDEX_ACCESSORIES
      @help_window.set_text(ITEM_HELP_ACCESSORIES, 1)
    elsif @index == ITEM_INDEX_VALUABLES
      @help_window.set_text(ITEM_HELP_VALUABLES, 1)
    else
      @help_window.set_text(ITEM_HELP_ALL_ITEMS, 1)
    end
  end
end

#==============================================================================
# Window_ItemUse
#------------------------------------------------------------------------------
# Janela que exibe as opções de uso para cada item.
#==============================================================================

class Window_ItemUse < Window_Selectable
  #--------------------------------------------------------------------------
  # Inclusão das constantes do módulo Scene_ItemPlus
  #--------------------------------------------------------------------------
  include Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #    x      : coordenada X da janela
  #    y      : coordenada Y da janela
  #    width  : largura da janela
  #    height : altura da janela
  #--------------------------------------------------------------------------
  def initialize(x, y, mode, drop_enabled = true, usable = true)
    super(x, y, 124, 104)
    @mode = mode
    @usable = usable
    @drop_enabled = drop_enabled
    self.index = 0
    refresh
  end
  #--------------------------------------------------------------------------
  # Definição do modo
  #--------------------------------------------------------------------------
  def mode
    return @mode
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    create_contents
    case @mode
    when 0
      draw_item(0)
    when 1
      draw_item(1)
    end
  end
  #--------------------------------------------------------------------------
  # Desenho dos itens
  #    index : número de itens
  #--------------------------------------------------------------------------
  def draw_item(mode)
    self.contents.clear
    case mode
    when 0
      @item_max = 3
      self.contents.font.color.alpha = @usable ? 255 : 128
      self.contents.draw_text(0, 24 * ITEM_USE_INDEX, contents.width, 24, ITEM_USE_NAME, 1)
      self.contents.font.color.alpha = 255
      self.contents.draw_text(0, 24 * ITEM_VERIFY_INDEX, contents.width, 24, ITEM_VERIFY_NAME, 1)
      self.contents.font.color.alpha = @drop_enabled ? 255 : 128
      self.contents.draw_text(0, 24 * ITEM_DROP_INDEX, contents.width, 24, ITEM_DROP_NAME, 1)
    when 1
      @item_max = 3
      self.contents.draw_text(0, 24 * ITEM_USE_INDEX, contents.width, 24, ITEM_EQUIP_NAME, 1)
      self.contents.draw_text(0, 24 * ITEM_VERIFY_INDEX, contents.width, 24, ITEM_VERIFY_NAME, 1)
      self.contents.font.color.alpha = @drop_enabled ? 255 : 128
      self.contents.draw_text(0, 24 * ITEM_DROP_INDEX, contents.width, 24, ITEM_DROP_NAME, 1)
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do texto na janela de ajuda
  #--------------------------------------------------------------------------
  def update_help
    if @help_window != nil
      @help_window.contents.font.name  = ITEM_MENU_FONT
      @help_window.contents.font.color = @help_window.normal_color
      if ITEM_MENU_MODE == 0
        @help_window.set_text(item == nil ? "" : item.name + ": " + item.description, 1)
      elsif ITEM_MENU_MODE == 1
        @help_window.set_text(item == nil ? "" : item.description, 1)
      else
        @help_window.set_text("", 1)
      end
    end
  end
end

#==============================================================================
# Window_ItemPlus
#------------------------------------------------------------------------------
# Janela responsável pela exibição dos itens em posse.
#==============================================================================

class Window_ItemPlus < Window_Selectable
  #--------------------------------------------------------------------------
  # Inclusão das constantes do módulo Scene_ItemPlus
  #--------------------------------------------------------------------------
  include Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #    x      : coordenada X da janela
  #    y      : coordenada Y da janela
  #    width  : largura da janela
  #    height : altura da janela
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    super(x, y, width, height)
    if ITEM_MENU_MODE == 0
      @column_max = COLUMN_NUMBER
      @spacing = 0
    elsif ITEM_MENU_MODE == 1
      @column_max = 2
    end
    self.index = 0
    self.active = false
    refresh
  end
  #--------------------------------------------------------------------------
  # Resgate das informações dos itens
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # Itens a serem inclusos na lista
  #    item : item
  #--------------------------------------------------------------------------
  def include?(item)
    return false if item == nil
    if $game_temp.in_battle
      return false unless item.is_a?(RPG::Item)
    end
    return true
  end
  #--------------------------------------------------------------------------
  # Utems de uso possível
  #    item : item
  #--------------------------------------------------------------------------
  def enable?(item)
    return true
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for item in $game_party.items
      next unless include?(item)
      if $scene.is_a?(Scene_Item)
        if $scene.sort_type == ITEM_INDEX_ALL_ITEMS || nil
          @data.push(item)
        elsif $scene.sort_type == ITEM_INDEX_ITEMS
          @data.push(item) if not item.is_a?(RPG::Armor) || item.is_a?(RPG::Weapon)
        elsif $scene.sort_type == ITEM_INDEX_WEAPONS
          @data.push(item) if item.is_a?(RPG::Weapon)
        elsif $scene.sort_type == ITEM_INDEX_ARMORS
          @data.push(item) if item.is_a?(RPG::Armor) and item.kind == 2
        elsif $scene.sort_type == ITEM_INDEX_ACCESSORIES
          @data.push(item) if item.is_a?(RPG::Armor) and item.kind != 2
        elsif $scene.sort_type == ITEM_INDEX_VALUABLES
          @data.push(item) if item.price == 0
        end
      else
        @data.push(item)
      end
      if item.id == $game_party.last_item_id
        self.index = @data.size - 1
      end
    end
    @data.push(nil) if include?(nil)
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
  #--------------------------------------------------------------------------
  # Exibição do nome do item
  #    item    : itens (habilidades, armas e equipamentos são bem-vindos)
  #    x      : exibe na coordenada X
  #    y      : exibe na coordenada Y
  #    enabled : um espaço permitido. Fica translúcido quando falso
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, enabled = true)
    if item != nil
      draw_icon(item.icon_index, x, y, enabled)
      self.contents.font.name  = ITEM_MENU_FONT
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(x + 24, y, 172, WLH, item.name)
    end
  end
  #--------------------------------------------------------------------------
  # Desenho dos itens
  #    index : número de itens
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      number = $game_party.item_number(item)
      enabled = enable?(item)
      rect.width -= 4
      self.contents.font.color = normal_color
      if ITEM_MENU_MODE == 0
        item_width = self.width / @column_max
        align_m = (item_width - 24) / 2
        item_x = rect.x + align_m - 4
        draw_icon(item.icon_index, item_x, rect.y, enabled)
        self.contents.font.size = 12
        align_n = self.contents.font.size / 2
        self.contents.draw_text(item_x + align_n, rect.y + align_n, 24, 24, number.to_s, 2)
      elsif ITEM_MENU_MODE == 1
        draw_item_name(item, rect.x, rect.y, enabled)
        self.contents.draw_text(rect, sprintf(":%2d", number), 2)
      end
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do texto na janela de ajuda
  #--------------------------------------------------------------------------
  def update_help
    if @help_window != nil
      @help_window.contents.font.name  = ITEM_MENU_FONT
      @help_window.contents.font.color = normal_color
      if ITEM_MENU_MODE == 0
        @help_window.set_text(item == nil ? "" : item.name + ": " + item.description, 1)
      elsif ITEM_MENU_MODE == 1
        @help_window.set_text(item == nil ? "" : item.description, 1)
      else
        @help_window.set_text("", 1)
      end
    end
  end
end

#==============================================================================
# Window_Ask
#------------------------------------------------------------------------------
# Janela que exibe uma pergunta de reposta afirmativa ou negativa.
#==============================================================================

class Window_Ask < Window_Selectable
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, question, answer1, answer2)
    super(x, y, width, height)
    @question = question
    @answer1 = answer1
    @answer2 = answer2
    @item_max = 2
    refresh
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    contents.draw_text(0, WLH * 0, contents.width, WLH, @question, 1)
    contents.draw_text(0, WLH * 1, contents.width, WLH, @answer1, 1)
    contents.draw_text(0, WLH * 2, contents.width, WLH, @answer2, 1)
  end
  #--------------------------------------------------------------------------
  # Atualização do cursor
  #--------------------------------------------------------------------------
  def update_cursor
    cursor_rect.set(0, @index * WLH + WLH, contents.width, WLH)
  end
end

#==============================================================================
# Window_ItemVerify
#------------------------------------------------------------------------------
# Janela que exibe as informações do ítem na tela de itens.
#==============================================================================

class Window_ItemVerify < Window_Base
  #--------------------------------------------------------------------------
  # Inclusão das constantes do módulo Scene_ItemPlus
  #--------------------------------------------------------------------------
  include Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(x, y, item, type)
    super(x, y, 544, 54)
    @item = item
    @type = type
    @x = x
    @y = y
    refresh
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    case @type
    when 0
      @item = $data_items[@item.id]
    when 1
      @item = $data_weapons[@item.id]
    when 2
      @item = $data_armors[@item.id]
    end
    self.contents.draw_text(0, 0, contents.width, 24, @item.description, 1)
    @item_name_window = Window_Base.new(@x, @y - 56, 224, 56)
    @item_name_window.contents.font.name = ITEM_MENU_FONT
    @item_name_window.contents.font.color = @item_name_window.system_color
    @item_name_window.draw_icon(@item.icon_index, 0, 0)
    @item_name_window.contents.draw_text(24, 0, 168, 24, @item.name)
    @item_detail_window = Window_Base.new(@x + 224, @y - 56, 320, 56)
    @item_detail_window.contents.font.name = ITEM_MENU_FONT
    item_detail_refresh
  end
  #--------------------------------------------------------------------------
  # Atualização da janela de detalhes
  #--------------------------------------------------------------------------
  def item_detail_refresh
    if @type != 0
      @item_detail_window.contents.font.color = system_color
      @item_detail_window.contents.font.color.alpha = @item.atk != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 0, 0, 72, 24, "Atq:")
      @item_detail_window.contents.font.color.alpha = @item.def != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 1, 0, 72, 24, "Def:")
      @item_detail_window.contents.font.color.alpha = @item.spi != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 2, 0, 72, 24, "Int:")
      @item_detail_window.contents.font.color.alpha = @item.agi != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 3, 0, 72, 24, "Agi:")
      @item_detail_window.contents.font.color = normal_color
      @item_detail_window.contents.font.color.alpha = @item.atk != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 0, 0, 68, 24, @item.atk, 2)
      @item_detail_window.contents.font.color.alpha = @item.def != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 1, 0, 68, 24, @item.def, 2)
      @item_detail_window.contents.font.color.alpha = @item.spi != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 2, 0, 68, 24, @item.spi, 2)
      @item_detail_window.contents.font.color.alpha = @item.agi != 0 ? 255 : 128
      @item_detail_window.contents.draw_text(72 * 3, 0, 68, 24, @item.agi, 2)
    else
      case @item.occasion
      when 0
        str = ITEM_VERIFY_TEXT0
      when 1
        str = ITEM_VERIFY_TEXT1
      when 2
        str = ITEM_VERIFY_TEXT2
      when 3
        str = ITEM_VERIFY_TEXT3
      end
      @item_detail_window.contents.font.color = system_color
      @item_detail_window.contents.draw_text(0, 0, 288, 24, str, 1)
    end
  end 
  #--------------------------------------------------------------------------
  # Dispose
  #--------------------------------------------------------------------------
  def dispose
    self.contents.dispose
    super
    @item_name_window.dispose
    @item_detail_window.dispose if not @item_detail_window.nil?
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    self.contents.update
    super
    @item_name_window.update
    @item_detail_window.update if not @item_detail_window.nil?
  end
end

#==============================================================================
# Scene_Item
#------------------------------------------------------------------------------
# Classe de operações na tela de itens.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# * Classe totalmente reescrita.
#==============================================================================

class Scene_Item < Scene_Base
  #--------------------------------------------------------------------------
  # Inclusão das constantes do módulo Scene_ItemPlus
  #--------------------------------------------------------------------------
  include Scene_ItemPlus
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :sort_type
  #--------------------------------------------------------------------------
  # Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    # Cria um viewport
    @viewport = Viewport.new(0, 0, 544, 416)
    # Cria a janela com o nome "Ítens" nela
    if MNWA
      @menu_select_window = Window_Base.new(MNWV[0], MNWV[1], MNWV[2], MNWV[3])
      @menu_select_window.opacity = ITEM_MENU_OPACITY
      @menu_select_window.contents.font.name = ITEM_MENU_FONT
      @menu_select_window.contents.font.color = @menu_select_window.system_color
      @menu_select_window.contents.draw_text(0, 0, MNWV[2] - 32, 24, MENU_NAME, 1)
      @menu_select_window.viewport = @viewport
    end
    # Cria a janela que exibe o dinheiro contido pelo grupo
    if MGWA
      @gold_window = Window_Base.new(MGWV[0], MGWV[1], MGWV[2], MGWV[3])
      @gold_window.opacity = ITEM_MENU_OPACITY
      cx = @gold_window.contents.text_size(Vocab::gold).width
      @gold_window.contents.font.color = @gold_window.normal_color
      @gold_window.contents.draw_text(0, 0, MGWV[2] - 32 - cx - 2, 24, $game_party.gold.to_s, 2)
      @gold_window.contents.font.color = @gold_window.system_color
      @gold_window.contents.draw_text(0, 0, MGWV[2] - 32, 24, Vocab::gold, 2)
      @gold_window.viewport = @viewport
    end
    # Cria a janela de ajuda
    if HPWA
      @help_window = Window_Help.new
      @help_window.opacity = ITEM_MENU_OPACITY
      @help_window.x = HPWV[0]
      @help_window.y = HPWV[1]
      @help_window.width = HPWV[2]
      @help_window.height = HPWV[3]
      @help_window.create_contents
      @help_window.viewport = @viewport
    end
    # Cria a janela de seleção de exibição de itens
    @item_type_window = Window_ItemType.new
    @item_type_window.opacity = ITEM_MENU_OPACITY
    @item_type_window.viewport = @viewport
    @sort_type = @item_type_window.index
    # Cria a janela de ajuda da seleção de exibição de itens
    if MHWA
      @item_type_help_window = Window_Help.new
      @item_type_help_window.opacity = ITEM_MENU_OPACITY
      @item_type_help_window.x = MHWV[0]
      @item_type_help_window.y = MHWV[1]
      @item_type_help_window.width = MHWV[2]
      @item_type_help_window.height = MHWV[3]
      @item_type_help_window.create_contents
      @item_type_help_window.viewport = @viewport
      @item_type_window.help_window = @item_type_help_window
    end
    # Cria a janela de itens
    @item_window = Window_ItemPlus.new(MIWV[0], MIWV[1], MIWV[2], MIWV[3])
    @item_window.opacity = ITEM_MENU_OPACITY
    @item_window.viewport = @viewport
    @item_window.help_window = @help_window if HPWA
    @item_window.cursor_rect.empty
    # Cria a janela de alvo
    @target_window = Window_MenuStatus.new(0, 0)
    @target_window.visible = false
    @target_window.active = false
    # Cria uma janela de equipamento nula
    @equip_window = nil
    @not_update_equip = false
    @equiped = false
    # Cria uma janela de uso de itens nula
    @item_use_window = nil
    @not_update = false
    # Cria a janela de pergunta
    @ask_window = nil
  end
  #--------------------------------------------------------------------------
  # Criação do background do menu
  #--------------------------------------------------------------------------
  def create_menu_background
    @menuback_sprite = Sprite.new
    if ITEM_MENU_BACK == nil
      @menuback_sprite.bitmap = $game_temp.background_bitmap
      @menuback_sprite.color.set(16, 16, 16, 128)
    else
      @menuback_sprite.bitmap = Cache.system(ITEM_MENU_BACK)
    end
    update_menu_background
  end
  #--------------------------------------------------------------------------
  # Fim do processo
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @menu_select_window.dispose if @menu_select_window != nil
    @gold_window.dispose if @gold_window != nil
    @viewport.dispose
    @help_window.dispose if HPWA
    @item_type_window.dispose
    @item_type_help_window.dispose if MHWA
    @item_window.dispose
    @target_window.dispose
  end
  #--------------------------------------------------------------------------
  # Retornar à tela original
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(0)
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @menu_select_window.update if @menu_select_window != nil
    @gold_window.update if @gold_window != nil
    @help_window.update if HPWA
    @item_type_window.update
    @item_type_help_window.update if MHWA
    @target_window.update
    unless @not_update_equip
      @equip_window.update if @equip_window != nil
      @equip_window.refresh if @equip_window != nil
    end
    if @item_use_window != nil
      update_item_use_selection
      unless @not_update
        @item_use_window.update
        @item_use_window.refresh
      end
    elsif @item_verify_window != nil
      update_item_verify_window(false)
    elsif @item_verify_window2 != nil
      update_item_verify_window(true)
    elsif @ask_window != nil
      update_ask
    elsif @equip_window != nil and @equip_window.active
      update_equip_two_hands
    elsif @item_type_window.active
      update_item_type_selection
    elsif @item_window.active
      update_item_selection
      @item = @item_window.item
      if Input.press?(Input::A) and @item != nil
        if @item.is_a?(RPG::Weapon)
          @item_verify_window = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 1)
        elsif @item.is_a?(RPG::Armor)
          @item_verify_window = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 2)
        else
          @item_verify_window = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 0)
        end
        @viewport.color.alpha = 128
      end
    elsif @target_window.active
      update_target_selection
    end
  end
  #--------------------------------------------------------------------------
  # Tipo de exibição de itens
  #--------------------------------------------------------------------------
  def sort_type
    return @sort_type
  end
  #--------------------------------------------------------------------------
  # Valor do tipo de exibição de itens
  #--------------------------------------------------------------------------
  def sort_type=(value)
    return @sort_type = value
  end
  #--------------------------------------------------------------------------
  # Definição do equipamento
  #--------------------------------------------------------------------------
  def equip?
    if @item.is_a?(RPG::Weapon) or @item.is_a?(RPG::Armor)
      return true
    else
      return false
    end
  end
  #--------------------------------------------------------------------------
  # Atualização da seleção do tipo de exibição dos itens
  #--------------------------------------------------------------------------
  def update_item_type_selection
    @sort_type = @item_type_window.index
    @item_window.refresh
    @item_window.cursor_rect.empty
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      @item_window.index = 0
      @item_type_window.active = false
      @item_window.active = true
    end
  end
  #--------------------------------------------------------------------------
  # Atualização da seleção de itens
  #--------------------------------------------------------------------------
  def update_item_selection
    @item_window.update
    @item_window_actived = true
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @item_window.index = 0
      @item_window.cursor_rect.empty
      @item_window.help_window.set_text("") if HPWA
      @item_window.active = false
      @item_type_window.active = true
      @item_window_actived = false
    elsif Input.trigger?(Input::C)
      @item_window_actived = false
      @item = @item_window.item
      if @item != nil
        $game_party.last_item_id = @item.id
      end
      if equip?
        Sound.play_decision
        determine_use(1)
      else
        if @item != nil
          Sound.play_decision
          determine_use(0)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # Atualização da verificação de item
  #--------------------------------------------------------------------------
  def update_item_verify_window(from_item_use_window)
    if from_item_use_window
      if Input.trigger?(Input::B)
        Sound.play_cancel
        @item_verify_window2.dispose
        @item_verify_window2 = nil
        if equip?
          determine_use(1)
        else
          determine_use(0)
        end
        @viewport.color.alpha = -128
        @item_use_window.index = ITEM_VERIFY_INDEX
      end
    else
      @item_window.active = false
      if not Input.press?(Input::A)
        @item_window.active = true
        @item_verify_window.dispose
        @item_verify_window = nil
        @viewport.color.alpha = -128
        @item_window.active = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # Decisão de uso
  #--------------------------------------------------------------------------
  def determine_use(mode)
    @item_window.active = false
    xa = @item_window.cursor_rect.x + (@item_window.x + 16) + 4
    xb = (@item_window.width - 32) / @item_window.column_max
    xn = xa + xb
    yn = @item_window.cursor_rect.y + @item_window.y
    if xn > 544 - 124
      xn = xn - 124 - xb - 8
    end
    if yn > 416 - 104
      yn = yn - 104 + 56
    end
    case mode
    when 0
      @droppable = @item.price > 0
      @usable = $game_party.item_can_use?(@item)
      @item_use_window = Window_ItemUse.new(xn, yn, 0, @droppable, @usable)
    when 1
      if not ITEM_EQUIP_ACTIVE
        @droppable = @item.price > 0
        @usable = $game_party.item_can_use?(@item)
        @item_use_window = Window_ItemUse.new(xn, yn, 0, @droppable, @usable)
      else
        @droppable = @item.price > 0
        @item_use_window = Window_ItemUse.new(xn, yn, 1, @droppable)
      end
    end
    @not_update = false
  end
  #--------------------------------------------------------------------------
  # Atualização da seleção tipo de uso do ítem
  #--------------------------------------------------------------------------
  def update_item_use_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @not_update = true
      @item_use_window.active = false
      @item_use_window.dispose
      @item_use_window = nil
      @item_window.active = true
    elsif Input.trigger?(Input::C)
      case @item_use_window.index
      when ITEM_USE_INDEX
        case @item_use_window.mode
        when 0
          if @usable
            Sound.play_decision
            @not_update = true
            @item_use_window.active = false
            @item_use_window.dispose
            @item_use_window = nil
            @item_window.active = true
            determine_item
          else
            Sound.play_buzzer
          end
        when 1
          if ITEM_EQUIP_ACTIVE
            Sound.play_decision
            @not_update = true
            @item_use_window.active = false
            @item_use_window.dispose
            @item_use_window = nil
            @item_window.active = true
            @equiped = false
            determine_equip
          else
            Sound.play_buzzer
          end
        end
      when ITEM_VERIFY_INDEX
        Sound.play_decision
        @not_update = true
        @item_use_window.active = false
        @item_use_window.dispose
        @item_use_window = nil
        @item_window.active = true
        if @item.is_a?(RPG::Weapon)
          @item_verify_window2 = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 1)
        elsif @item.is_a?(RPG::Armor)
          @item_verify_window2 = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 2)
        else
          @item_verify_window2 = Window_ItemVerify.new(0, ((544 - 112) / 2), @item, 0)
        end
        update_item_verify_window(true)
        @viewport.color.alpha = 128
      when ITEM_DROP_INDEX
        if @droppable
          Sound.play_decision
          question = ITEM_DROP_QUESTION
          answer1 = ITEM_DROP_ANSWER1
          answer2 = ITEM_DROP_ANSWER2
          temp_bitmap = Bitmap.new(544, 416)
          width = temp_bitmap.text_size(question).width
          x = (544 - (width + 32)) / 2
          y = (416 - ((24 * 3) + 32)) / 2
          @ask_window = Window_Ask.new(x, y, width + 32, 24 * 3 + 32, question,
          answer1, answer2)
          @ask_window.contents.font.name = ITEM_MENU_FONT
          @ask_window.refresh
          @ask_window.index = 1
          @ask_update = true
          @not_update = true
          @item_use_window.active = false
          @item_use_window.dispose
          @item_use_window = nil
          @item_window.active = true
        else
          Sound.play_buzzer
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # Atualização da pergunta
  #--------------------------------------------------------------------------
  def update_ask
    @viewport.color.alpha = 128
    if @ask_update
      @ask_window.update
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @ask_update = false
      @ask_window.dispose
      @ask_window = nil
      if equip?
        determine_use(1)
      else
        determine_use(0)
      end
      @item_use_window.index = ITEM_DROP_INDEX
      @viewport.color.alpha = -128
    elsif Input.trigger?(Input::C)
      case @ask_window.index
      when 0
        Sound.play_equip
        $game_party.lose_item(@item, $game_party.item_number(@item))
        @ask_update = false
        @ask_window.dispose
        @ask_window = nil
        @item_window.refresh
        if @item_window.item == nil
          @item_window.index = @item_window.item_max - 1
        end
        @viewport.color.alpha = -128
      when 1
        Sound.play_cancel
        @ask_update = false
        @ask_window.dispose
        @ask_window = nil
        if equip?
          determine_use(1)
        else
          determine_use(0)
        end
        @item_use_window.index = ITEM_DROP_INDEX
        @viewport.color.alpha = -128
      end
    end
  end
  #--------------------------------------------------------------------------
  # Decisão de item
  #--------------------------------------------------------------------------
  def determine_item
    if @item.for_friend?
      xa = @item_window.cursor_rect.x + @item_window.x + 8
      xb = @item_window.width / @item_window.column_max
      xn = xa + xb
      show_target_window
      if @item.for_all?
        @target_window.index = 99
      else
        if $game_party.last_target_index < @target_window.item_max
          @target_window.index = $game_party.last_target_index
        else
          @target_window.index = 0
        end
      end
    else
      use_item_nontarget
    end
  end
  #--------------------------------------------------------------------------
  # Decisão do equipamento
  #--------------------------------------------------------------------------
  def determine_equip
    xa = @item_window.cursor_rect.x + @item_window.x + 8
    xb = @item_window.width / @item_window.column_max
    xn = xa + xb
    show_target_window
    if $game_party.last_target_index < @target_window.item_max
      @target_window.index = $game_party.last_target_index
    else
      @target_window.index = 0
    end
    @last_target_index = -1
    @actor = $game_party.members[@target_window.index]
    y = @target_window.cursor_rect.y + @target_window.y + (24 * 5)
    if y + (24 * 5) + 32 > 416
      y = @target_window.y + @target_window.cursor_rect.y - (24 * 5) - 24
    end
    @equip_status_window = Window_EquipStatus.new(0, y, @actor)
    @equip_window = Window_Equip.new(@equip_status_window.width, y, @actor)
    @equip_window.active = false
    @not_update_equip = false
    @equip_window.refresh if @equip_window != nil
  end
  #--------------------------------------------------------------------------
  # Exibição da janela de alvo
  #    right : alinhado à direita (falso se esquerda)
  #--------------------------------------------------------------------------
  def show_target_window
    @item_window.active = false
    width_remain = 544 - @target_window.width
    @target_window.x = width_remain / 2
    @target_window.visible = true
    @target_window.active = true
    x = @target_window.x
    y = @target_window.y
    width = @target_window.width
    height = @target_window.height
    @viewport.color.alpha = 128
    @viewport.ox = 0
  end
  #--------------------------------------------------------------------------
  # Ocultar janela de alvo
  #--------------------------------------------------------------------------
  def hide_target_window
    @target_window.visible = false
    @target_window.active = false
    @viewport.rect.set(0, 0, 544, 416)
    @viewport.ox = 0
    if equip?
      if $game_party.item_number(@item) == 0
        @item_window.index = 0
        @item_window.active = true
      else
        determine_use(1)
      end
    else
      if $game_party.item_number(@item) == 0
        @item_window.index = 0
        @item_window.active = true
      else
        determine_use(0)
      end
    end
    @item_use_window.index = ITEM_USE_INDEX if !@item_use_window.nil?
    @viewport.color.alpha = -128
  end
  #--------------------------------------------------------------------------
  # Atualização da seleção de alvo
  #--------------------------------------------------------------------------
  def update_target_selection
    if @last_target_index != @target_window.index and equip?
      @equip_window.dispose
      @equip_status_window.dispose
      @actor = $game_party.members[@target_window.index]
      y = @target_window.cursor_rect.y + @target_window.y + (24 * 5)
      if y + (24 * 5) + 32 > 416
        y = @target_window.y + @target_window.cursor_rect.y - (24 * 5) - 24
      end
      @equip_status_window = Window_EquipStatus.new(0, y, @actor)
      @equip_window = Window_Equip.new(@equip_status_window.width, y, @actor)
      @equip_window.active = false
      @not_update_equip = true
      @equip_window.refresh if @equip_window != nil
      @last_target_index = @target_window.index
      if @item.is_a?(RPG::Weapon)
        if @actor.two_swords_style || @item.two_handed
          @equip_window.index = 0
          @equip_window.cursor_rect.set(0, 0, @equip_window.width - 32, 48)
        else
          @equip_window.index = 0
        end
      elsif @item.is_a?(RPG::Armor)
        case @item.kind
        when 0
          @equip_window.index = 1
        when 1
          @equip_window.index = 2
        when 2
          @equip_window.index = 3
        when 3
          @equip_window.index = 4
        end
      end
      if @actor.equippable?(@item)
        temp_actor = @actor.clone
        temp_actor.change_equip(@equip_window.index, @item_window.item, true)
        new_atk = temp_actor.atk
        new_def = temp_actor.def
        new_spi = temp_actor.spi
        new_agi = temp_actor.agi
        @equip_status_window.set_new_parameters(new_atk, new_def, new_spi, new_agi)
      end
      if not @actor.equippable?(@item) or $game_party.item_number(@item) == 0
        @equip_window.cursor_rect.empty
      end
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      if $game_party.item_number(@item) == 0    # Se usar itens até 0
        @item_window.refresh                    # Atualizar janela
      end
      if @equip_window != nil
        @not_update_equip = true
        @equip_status_window.dispose
        @equip_status_window = nil
        @equip_window.dispose
        @equip_window = nil
      end
      hide_target_window
    elsif Input.trigger?(Input::C)
      if not $game_party.item_can_use?(@item) and not equip?
        Sound.play_buzzer
      else
        if @actor.nil?
          @actor = $game_party.members[@target_window.index]
        end
        if @item.is_a?(RPG::Weapon) and @actor.two_swords_style and not @item.two_handed
          Sound.play_decision
          @equip_window.active = true
          @target_window.active = false
          @not_update_equip = false
        else
          determine_target
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # Definição do equipamento para personagem com estilo duas mãos
  #--------------------------------------------------------------------------
  def update_equip_two_hands
    @equip_status_window.update
    @equip_status_window.refresh
    temp_actor = @actor.clone
    temp_actor.change_equip(@equip_window.index, @item_window.item, true)
    new_atk = temp_actor.atk
    new_def = temp_actor.def
    new_spi = temp_actor.spi
    new_agi = temp_actor.agi
    @equip_status_window.set_new_parameters(new_atk, new_def, new_spi, new_agi)
    @equip_window.item_max = 2
    if Input.trigger?(Input::B)
      Sound.play_cancel
      if @actor.two_swords_style || @item.two_handed
        @equip_window.index = 0
        @equip_window.cursor_rect.set(0, 0, @equip_window.width - 32, 48)
      else
        @equip_window.index = 0
      end
      @equip_window.active = false
      @target_window.active = true
      @not_update_equip = true
    elsif Input.trigger?(Input::C)
      determine_target
    end
  end
  #--------------------------------------------------------------------------
  # Definição do alvo
  #    Se não houver efeito, tocar SE de erro.
  #--------------------------------------------------------------------------
  def determine_target
    used = false
    if not equip? and @item.for_all?
      for target in $game_party.members
        target.item_effect(target, @item)
        used = true unless target.skipped
      end
    elsif equip?
      if @actor.equippable?(@item) and $game_party.item_number(@item) != 0
        Sound.play_equip
        @actor.change_equip(@equip_window.index, @item_window.item)
        item_window_last_index = @item_window.index
        @equip_window.refresh
        @item_window.refresh
        @item_window.index = item_window_last_index
        @equip_status_window.update
        @equip_status_window.refresh
      else
        Sound.play_buzzer
      end
    else
      $game_party.last_target_index = @target_window.index
      target = $game_party.members[@target_window.index]
      target.item_effect(target, @item)
      used = true unless target.skipped
    end
    if not equip?
      if used
        use_item_nontarget
      else
        Sound.play_buzzer
      end
    end
  end
  #--------------------------------------------------------------------------
  # Uso de item (sem alvo)
  #--------------------------------------------------------------------------
  def use_item_nontarget
    Sound.play_use_item
    $game_party.consume_item(@item)
    @item_window.draw_item(@item_window.index)
    @target_window.refresh
    if $game_party.all_dead?
      $scene = Scene_Gameover.new
    elsif @item.common_event_id > 0
      $game_temp.common_event_id = @item.common_event_id
      $scene = Scene_Map.new
    end
  end
end