RESIDENT EVIL MENU

#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  Esta clase ejecuta el procesamiento de la pantalla del menú
#====================#========================================================
# Por: AlanZdr       #
# Traducción: Alojzy #
#====================#
module RE_MENU
  #--------------------------------------------------------------------------
  # * Recetas de combinación de objetos
  # * Colocar Recipe[a] = [b, c, d] siendo:
  # * a el número de la receta contando desde el "1"
  # * b y c el ID de los ítems que serán combinados
  # * d el ítem que será creado a partir de los otros
  #--------------------------------------------------------------------------
 
  Recipe = {}
  Recipe[1] = [20, 21 , 1]
  Recipe[2] = [12, 15, 16]
  Recipe[3] = [13, 16, 17]
  Recipe[4] = [15, 14, 17]
  Recipe[5] = [12, 12, 18]
  Recipe[6] = [12, 18, 19]
  #--------------------------------------------------------------------------
  # * Vocabulario del menú
  #--------------------------------------------------------------------------
  # * Menú que muestra el ítem equipado
  Equip = "Equipado: "
  # * Para tirar ítems
  Descarte = "Tirar"
  # * Para combinar ítems
  Combine = "Combinar"
  # * Para usar ítems
  Use = "Usar"
  # * Para equipar ítems
  Equipe = "Equipar"
  # * Para la cabecera del inventario
  Inventario = "Inventario"
  # * Para la cabecera de los ítems relevantes
  Key_itens = "Documentos"
  # * Para la ventana de ayuda, nombre de la descripción
  Help_desc = "Descripción: "
  # * Para la ventana de ayuda, nombre para el ítem
  Help_name = "Nombre: "
 
 
  #--------------------------------------------------------------------------
  # * Son expulsados cuando combinas los ítems
  #--------------------------------------------------------------------------
  def self.playcombine
      Sound.play_use_item
  end
 
end
 
 
 
 
 
 
 
#==============================================================================
# ** Window_Help
#------------------------------------------------------------------------------
#  Esta ventana muestra explicaciones sobre habilidades, ítems y otras informaciones
#==============================================================================
 
class RE_Window_Help < Window_Base
  #--------------------------------------------------------------------------
  # * Inicialización del objeto
  #     line_number : número de líneas
  #--------------------------------------------------------------------------
  def initialize(line_number = 3)
    super(0, 150, 345, Graphics.height - 150)
  end
  #--------------------------------------------------------------------------
  # * Configuración de texto
  #     text : texto
  #--------------------------------------------------------------------------
  def set_text(text)
    if text != @text
      @text = text
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Limpieza
  #--------------------------------------------------------------------------
  def clear
    set_text("")
  end
  #--------------------------------------------------------------------------
  # * Definición de ítem
  #     item : habilidades, ítems, etc.
  #--------------------------------------------------------------------------
  def set_item(item)
    set_text(item ? item.description : "")
    @item = item
  end
  #--------------------------------------------------------------------------
  # * Renovación
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    if @item != nil
    
      draw_text(5, 70, 150, 50, RE_MENU::Help_desc)
      draw_text(5, 100, 300, 100, @text)
      #draw_text_ex(5, 170, @text)
      draw_text(5, 0 , 350, 50, RE_MENU::Help_name + @item.name)
    end
  
  end
end
 
#==============================================================================
# ** Window_MenuCommand
#------------------------------------------------------------------------------
#  Esta ventana muestra los comandos del menú
#==============================================================================
class MenuCommand < Window_HorzCommand
  #--------------------------------------------------------------------------
  # * Inicialización de la posición del comando de selección (método de clase)
  #--------------------------------------------------------------------------
  def self.init_command_position
    @@last_command_symbol = nil
  end
  #--------------------------------------------------------------------------
  # * Inicialización del objeto
  #--------------------------------------------------------------------------
  def initialize
    super(244, 0)
  end
  #--------------------------------------------------------------------------
  # * Adquisición del ancho de la ventana
  #--------------------------------------------------------------------------
  def window_width
    return 300
  end
 
  #--------------------------------------------------------------------------
  # * Adquisición del largo de la ventana
  #--------------------------------------------------------------------------
  def window_height
    50
  end
  #--------------------------------------------------------------------------
  # * Adquisición del número de líneas mostradas
  #--------------------------------------------------------------------------
  def col_max
    return 3
  end
  #def visible_line_number
   # 3
 # end
  #--------------------------------------------------------------------------
  # * Creación de la lista de comandos
  #--------------------------------------------------------------------------
  def make_command_list
    add_main_commands
    add_game_end_command
  end
  #--------------------------------------------------------------------------
  # * Adición de los comandos principales
  #--------------------------------------------------------------------------
  def add_main_commands
    add_command(RE_MENU::Inventario,   :item,   main_commands_enabled)
    add_command(RE_MENU::Key_itens, :key_item, main_commands_enabled)
  end
 
  #--------------------------------------------------------------------------
  # * Definición de habilitación de los comandos principales
  #--------------------------------------------------------------------------
  def main_commands_enabled
    $game_party.exists
  end
  #--------------------------------------------------------------------------
  # * Adición de comando de "Fin del Juego"
  #--------------------------------------------------------------------------
  def add_game_end_command
    add_command(Vocab::game_end, :game_end)
  end
  #--------------------------------------------------------------------------
  # * Definición del resultado al presionar el botón de confirmación
  #--------------------------------------------------------------------------
  def process_ok
    @@last_command_symbol = current_symbol
    super
  end
  #--------------------------------------------------------------------------
  # * Definición de la ventana de ítems
  #     item_window : ventana de ítems
  #--------------------------------------------------------------------------
  def item_window=(item_window)
    @item_window = item_window
    @item_window.category = current_symbol
  end
end
 
class Window_ItemList < Window_Selectable
  #--------------------------------------------------------------------------
  # * Inicialización del objeto
  #     x      : coordenada X
  #     y      : coordenada Y
  #     width  : ancho
  #     height : largo
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    super
    @category = :none
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Definición de categoría
  #--------------------------------------------------------------------------
  def category=(category)
    return if @category == category
    @category = category
    refresh
    self.oy = 0
  end
  #--------------------------------------------------------------------------
  # * Adquisición del número de columnas
  #--------------------------------------------------------------------------
  def col_max
    return 2
  end
 
  #--------------------------------------------------------------------------
  # * Adquisición del número máximo de ítems
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # * Adquisición de espaciamiento entre los ítems
  #--------------------------------------------------------------------------
  def spacing
    return 5
  end
 
  #--------------------------------------------------------------------------
  # * Adquisición del largo o altura del ítem
  #--------------------------------------------------------------------------
  def item_height
    80
  end
  #--------------------------------------------------------------------------
  # * Adquisición de la información del ítem
  #--------------------------------------------------------------------------
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  #--------------------------------------------------------------------------
  # * Definición de habilitación de selección
  #--------------------------------------------------------------------------
  def current_item_enabled?
    enable?(@data[index])
  end
  #--------------------------------------------------------------------------
  # * Inclusión del ítem en la lista
  #     item : ítem
  #--------------------------------------------------------------------------
  def include?(item)
    case @category
    when :item
      item.is_a?(RPG::Item) && !item.key_item? or item.is_a?(RPG::Weapon)
    when :key_item
      item.is_a?(RPG::Item) && item.key_item?
    else
      false
    end
  end
  #--------------------------------------------------------------------------
  # * Definición de ítems disponibles para usar
  #--------------------------------------------------------------------------
  def usable?(item)
    if item.is_a?(RPG::Weapon)
      return true
    else
      return $game_party.usable?(item)
    end
    return false
  
  end
  #--------------------------------------------------------------------------
  # * Definición de habilitación del ítem
  #     item : ítem
  #--------------------------------------------------------------------------
  def enable?(item)
    #$game_party.usable?(item)
    return true
  end
  #--------------------------------------------------------------------------
  # * Creación de la lista de ítems
  #--------------------------------------------------------------------------
  def make_item_list
    @data = $game_party.all_items.select {|item| include?(item) }
    @data.push(nil) if include?(nil)
  end
  #--------------------------------------------------------------------------
  # * Retorno a la selección anterior
  #--------------------------------------------------------------------------
 
  def select_last
    select(@data.index($game_party.last_item.object) || 0)
  end
  #--------------------------------------------------------------------------
  # * Diseñar el ítem
  #--------------------------------------------------------------------------
 
  def draw_item_name(item, x, y, enabled = true, width = 80)
    return unless item
    draw_icon(item.icon_index, x + 30, y + 20, enabled)
    change_color(normal_color, enabled)
    draw_text(x + 5, y + 50, width, line_height, item.name)
  end
  #--------------------------------------------------------------------------
  # * Diseño de un ítem
  #     index : índice del ítem
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
  
    if item
      rect = item_rect(index)
      rect.width -= 4
      draw_item_name(item, rect.x , rect.y, true)
      rect.y -= 20
      draw_item_number(rect, item)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Diseño del número de ítems poseído
  #     rect : rectángulo
  #     item : ítem
  #--------------------------------------------------------------------------
  def draw_item_number(rect, item)
    draw_text(rect, sprintf(" %2d", $game_party.item_number(item)), 2)
  end
  #--------------------------------------------------------------------------
  # * Actualización de la ventana de ayuda
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(item)
    @help_window.refresh
  end
 
  #--------------------------------------------------------------------------
  # * Renovación
  #--------------------------------------------------------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items
    update_help
  end
end
 
class Comand_itens < Window_Command
  #--------------------------------------------------------------------------
  # * Inicialización del objeto
  #--------------------------------------------------------------------------
  def initialize
    super(300, 200)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Adquisición del largo y ancho de la ventana
  #--------------------------------------------------------------------------
  def window_width
    return 100
  end
  def window_height
    return 100
  end
  def activeCombine=(active)
    @activecombine = active
  end
  def usename=(name)
    @usename = name
  end
  def activeCombine
    return @activecombine
  end
  def usename
    return @usename
  end
  def important=(value)
    @important = value
  end
  def important
    return @important
  end
  def isuse=(value)
    @isuse = value
  end
  def isuse
    return @isuse
  end
  #--------------------------------------------------------------------------
  # * Creación de la lista de comandos
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(usename,   :usar,   isuse)
    add_command(RE_MENU::Combine,  :combine,  activeCombine)
    add_command(RE_MENU::Descarte,  :discart,  important)
  end
end
class Scene_Menu < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Inicialización del proceso
  #--------------------------------------------------------------------------
  def start
    super
    create_Help_window
    create_command_window
    create_item_window
    create_status_window
    create_command_itens
    create_Equip_window
    @iscombine = false
    @actor = $game_party.members[0]
  end
 
  #--------------------------------------------------------------------------
  # * Creación de la ventana de comandos
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = MenuCommand.new
    @command_window.set_handler(:item,      method(:command_item))
    @command_window.set_handler(:key_item,      method(:command_item))
    @command_window.set_handler(:game_end,  method(:command_game_end))
    @command_window.set_handler(:cancel,    method(:return_scene))
  end
 
  #--------------------------------------------------------------------------
  # * Creación de la ventana de ítems
  #--------------------------------------------------------------------------
  def create_item_window
    wy = @command_window.y + @command_window.height + 100
    wh = Graphics.height - wy
    @item_window = Window_ItemList.new(344, wy, 200, wh)
    @item_window.help_window = @help_window
    @item_window.set_handler(:ok,     method(:on_item_ok))
    @item_window.set_handler(:cancel, method(:on_item_cancel))
    @command_window.item_window = @item_window
    #@command_window.item_window = @item_window
  end
  #--------------------------------------------------------------------------
  # * Creación de la ventana de comandos de los ítems
  #--------------------------------------------------------------------------
  def create_command_itens
    @command_item = Comand_itens.new
    @command_item.set_handler(:usar,      method(:use_item))
    @command_item.set_handler(:combine,      method(:combine_item))
    @command_item.set_handler(:discart,  method(:discart_item))
    @command_item.set_handler(:cancel,    method(:return_itens))
    @command_item.visible = false
    @command_item.active = false
  end
 
  #--------------------------------------------------------------------------
  # * Creación de las ventanas
  #--------------------------------------------------------------------------
  def create_status_window
    @Status_window = Window_Base.new(0,0,245,150)
    @Status_window.contents.clear
    @Status_window.draw_actor_face(@actor, 1, 10)
    @Status_window.draw_text(100, 10 , 120, 50, @actor.name)
    @Status_window.draw_actor_hp(@actor, 100, 40, 120)
  end
 
  def create_Help_window
    @help_window = RE_Window_Help.new()
  end
  def create_Equip_window
    @Equip_window = Window_Base.new(244,50,300,100)
    @Equip_window.contents.clear
    if @actor.equips[0] != nil
      @Equip_window.draw_icon(@actor.equips[0].icon_index, 30, 20, true)
      @Equip_window.draw_text(0, -15 , 120, 50, RE_MENU::Equip)
      @Equip_window.draw_text(10, 40 , 150, 50, @actor.equips[0].name)
    end
  
  
  end
  def use_item
    if @item.is_a?(RPG::Weapon)
      @actor.change_equip(0,@item)
      Sound.play_equip
    else
      Sound.play_use_item
      @actor.use_item(@item)
      use_item_to_actors
    
    end
    return_itens
    refresh
    check_common_event
  end
  def use_item_to_actors
    $game_party.members.each do |target|
      @item.repeats.times { target.item_apply(@actor, @item) }
    end
  end
  def check_common_event
    if $game_temp.common_event_reserved?
      SceneManager.goto(Scene_Map)
      @iscombine = false
    end
  end
  def combine_item
    if @iscombine == false
      @iscombine = true
      @combineitem = @item
    else
      recipe = RE_MENU::Recipe
      if @combineitem.id == @item.id
        if $game_party.item_number(@item) <= 1
          @combineitem = nil
        end
      end
      if @combineitem != nil
        for x in 1..recipe.size
        recipe1 = recipe[x]
      
          if recipe1[0] == @combineitem.id and recipe1[1] == @item.id
            @iscombine = false
            combineitens(x)
            break
          elsif recipe1[1] == @combineitem.id and recipe1[0] == @item.id
            @iscombine = false
            combineitens(x)
            break
          end
        end
      end
      if @iscombine == true
        Sound.play_buzzer
          @iscombine = false
      end
    
    end
    refresh
    return_itens
  
  
  end
  def combineitens(x)
    RE_MENU::playcombine
    $game_party.gain_item(@item, -1, true)
    $game_party.gain_item(@combineitem, -1, true)
    for y in 0..$data_items.size
        novoitem = $data_items[y] if y == RE_MENU::Recipe[x][2]
    end
    $game_party.gain_item(novoitem, 1)
  end
  def discart_item
    $game_party.gain_item(@item, -1, true)
    return_itens
  end
  def return_itens
    @command_item.visible = false
    @command_item.active = false
    @item_window.active = true
    @item_window.refresh
  end
  #--------------------------------------------------------------------------
  # * Ítem [Confirmación]
  #--------------------------------------------------------------------------
  def on_item_ok
    @item = @item_window.item
    if @item != nil
      if @item.is_a?(RPG::Weapon)
        @command_item.activeCombine = false
        @command_item.usename = RE_MENU::Equipe
      else
        @command_item.activeCombine = true
        @command_item.usename = RE_MENU::Use
      end
      if @item.is_a?(RPG::Item) and @item.key_item?
        @command_item.important = false
      else
        @command_item.important = true
      end
      if @item_window.usable?(@item)
        @command_item.isuse = true
      else
        @command_item.isuse = false
      end
    
      @command_item.refresh
      @command_item.visible = true
      @command_item.active = true
    else
      Sound.play_buzzer
      @item_window.active = true
    end
    @help_window.set_item(@item)
  end
  #--------------------------------------------------------------------------
  # * Ítem [Cancelación]
  #--------------------------------------------------------------------------
  def on_item_cancel
    @item_window.unselect
    @command_window.activate
    @iscombine = false
  end
 
  #--------------------------------------------------------------------------
  # * Comando [Ítem]
  #--------------------------------------------------------------------------
  def command_item
    @command_window.item_window = @item_window
    @item_window.activate
    @item_window.select_last
  
  end
  #--------------------------------------------------------------------------
  # * Comando [Fin del Juego]
  #--------------------------------------------------------------------------
  def command_game_end
    SceneManager.call(Scene_End)
  end
  #--------------------------------------------------------------------------
  # * Comandos individuales [Cancelación]
  #--------------------------------------------------------------------------
  def on_personal_cancel
    @status_window.unselect
    @command_window.activate
  end
 
  def refresh
    @actor = $game_party.members[0]
    @item_window.refresh
    @Equip_window.contents.clear
    if @actor.equips[0] != nil
      @Equip_window.draw_icon(@actor.equips[0].icon_index, 30, 20, true)
      @Equip_window.draw_text(0, -15 , 120, 50, RE_MENU::Equip)
      @Equip_window.draw_text(10, 40 , 150, 50, @actor.equips[0].name)
    end
    @Status_window.contents.clear
    @Status_window.draw_actor_face(@actor, 1, 10)
    @Status_window.draw_text(100, 10 , 120, 50, @actor.name)
    @Status_window.draw_actor_hp(@actor, 100, 40, 120)
  end
end