Script de criação de itens para RPG Maker VX Ace

[RGSS3] Crafting.rb

#==============================================================================
# Crafting | v1.0.0 | por Brandt
#
# para RPG Maker VX Ace
#------------------------------------------------------------------------------
#  Clássico script de cena de forja. Feito visando compatibilidade com a
# interface padrão do VX Ace e fácil extensibilidade.
#  O script foca em crafting realizado pelos próprios membros do grupo, em
# comparação a crafting feito por um NPC. Por isso, os requisitos de criação
# de itens podem envolver atributos dos personagens como classe e nível.
#==============================================================================
#==============================================================================
# Utilização
#------------------------------------------------------------------------------
#  O script é quase totalmente configurado pelas notas dos itens no banco de
# dados.
#  As notas completas para um item do script respeitam o seguinte formato:
#
#     [Craftable]
#     Type=Magic
#     Materials=W4,I21*5
#     Class=1
#     Rate=60%
#     Break=15%
#     Level=15
#   
#  Maiúsculas e minúsculas não são consideradas.
#  Resumidamente, os campos são:
#   • Type      : Método de criação do item.
#   • Materials : Materiais para criação do item.
#   • Class     : ID da classe de personagem necessária para criar o item.
#   • Rate      : Taxa de sucesso.
#   • Break     : Taxa de perda de equipamentos.
#   • Level     : Nível mínimo para criação do item.
#
#  Para descrições detalhadas de cada campo, veja suas respectivas
# especificações abaixo.
#  Para cada item, arma ou armadura do banco de dados que possa ser criada
# através da cena de Crafting, é necessário incluir no mínimo o cabeçalho
# [Craftable] e os campos Type e Materials. Todos os outros campos são
# opcionais.
#
#  A forja acontece em uma cena própria, que pode ser chamada pelo seguinte
# comando de script:
#
#   Crafting.call([<Type>[, <Type>[, ...]]])
#
#  Onde "<Type>" identifica o tipo de item a ser criado na cena e [] indica
# argumentos opcionais. Seguem exemplos de chamadas válidas:
#
#   Crafting.call('Basic')                    # Apenas itens normais
#   Crafting.call('Basic', 'Magic')           # Itens normais e mágicos
#   Crafting.call('Magic', 'Potion', 'Ammo')  # Itens mágicos, poções e munição
#
#  O script é agnóstico aos nomes do tipos, apenas garanta que são únicos e
# que sejam exatamente iguais aos configurados no banco de dados.
#
#  As configurações relacionadas à cena de criação devem ser feitas nos módulos
# Crafting::Sound (para sons) e Crafting::Vocab (para textos).
#==============================================================================
#==============================================================================
# Especificação dos Campos
#------------------------------------------------------------------------------
# • Type  : Método de criação do item
#
#    Esse campo determina o tipo de criação do item, e é usado para distinguir
#   os itens e permitir criar unidades de forja diferentes. Por exemplo, é
#   possível separar os itens em tipos 'Físico' e 'Mágico' e ter dois NPCs
#   diferentes: uma bigorna, que permite criar apenas itens do tipo 'Físico', e
#   um altar ou semelhante, que permite criar apenas itens do tipo 'Mágico'.
#    Por versatilidade, também é possível definir que uma cena inclua mais de
#   um tipo por vez.
#    Esse campo não tem formato, você pode escrever o que quiser nele desde
#   que caiba em uma linha. Lembre-se que maiúsculas e minúsculas não serão
#   consideradas.
#
# • Materials : Materiais para criação do item
#
#    Esse campo é composto por especificações de item separadas por vírgulas.
#   Um "item" pode ser um item, uma arma ou uma armadura do banco de dados.
#   A especificação de item é um pequeno código que indica o tipo do item
#   (I = item, W = arma, A = armadura), seu ID no banco de dados e
#   opcionalmente a quantidade necessária para a criação (se não especificada,
#   assume-se 1). Por exemplo:
#
#     I10       = 1 item de ID 10
#     W3*5      = 5 armas de ID 5
#     A1,I10*3  = 1 armadura de ID 1, 3 itens de ID 10
#
# • Class : ID da classe de personagem necessária para criar o item
#
#     Uma particularidade do script é que ele permite escolher um personagem
#    para a criação. Esse parâmetro define que o personagem precise ser de uma
#    classe específica para criar um item.
#     Se não especificado, assume-se que todas as classes podem criar o item.
#
# • Rate  : Taxa de sucesso
#
#     Esse campo define a chance de sucesso na criação do item. São permitidos
#    valores de ponto flutuante entre 0 e 1 (e.g. 0.3, 0.6, etc.) ou
#    porcentagens (que devem ser indicadas explicitamente com um %).
#     Se não especificado, assume-se 100%.
#     Em uma criação bem sucedida, perde-se todos os itens usados como material
#    inclusive equipamentos.
#     Em uma criação mal sucedida, perde-se todos os itens usado como material
#    exceto equipamentos; para estes, aplica-se a taxa de perda.
#
# • Break : Taxa de perda de equipamentos
#
#     Esse campo define a chance de perder cada equipamento usado como material
#    na criação do item. O formato é o mesmo do campo Rate.
#     Note que essa taxa só é aplicada caso a criação falhe, e de forma
#    independente para cada equipamento usado como material.
#     Se não especificado, assume-se 0%.
#
# • Level : Nível mínimo para criação do item
#
#     Esse campo determina o nível mínimo que o ator que realiza a criação
#    precisa ter para criar o item.
#==============================================================================
#==============================================================================
# Adicionais (Menu)
#------------------------------------------------------------------------------
#  O script permite integrar a criação de itens com o menu. Você pode habilitar
# isso por padrão alterando a constante Crafting::Config::CRAFT_FROM_MENU ou
# durante o jogo, pelo comando:
#
#     Crafting.enable_from_menu
#
#  Ou, para desativar a opção do menu:
#
#     Crafting.disable_from_menu
#
#  Para habilitar ou desabilitar a opção do menu (a opção desabilitada continua
# lá, mas não é utilizável), use os seguintes comandos por script:
#
#     Crafting.menu_enabled = true  # Habilita (padrão)
#     Crafting.menu_enabled = false # Desabilita
#
#  Lembre-se de atualizar a constante MENU_CRAFTING_TYPES_DEFAULT no módulo de
# configuração e/ou habilitar tipos de criação no menu com o comando:
#
#     Crafting.menu_enable_types('Type'[, 'Type'[, ...]])
#
#  Também é possível desabilitar um tipo de criação pelo menu:
#
#     Crafting.menu_disable_types('Type'[, 'Type'[, ...]])
#
#  Exemplos:
#
#     Crafting.menu_enable_types('Basic')
#     Crafting.menu_enable_types('Magic', 'Potion')
#
#     Crafting.menu_disable_types('Potion')
#     Crafting.menu_disable_types('Basic', 'Magic')
#
#  Caso não haja nenhum tipo de criação habilitada no menu, a opção é
# automaticamente desabilitada.
#==============================================================================

module Crafting
  VERSION = [1, 0, 0]
end

#==============================================================================
# * Crafting::Config
#------------------------------------------------------------------------------
#  Módulo de configuração geral do script.
#==============================================================================

module Crafting::Config
  
  # Adiciona a criação no menu
  CRAFT_FROM_MENU = false
  
  # Valor padrão para estado (ativo/inativo) da opção no menu
  MENU_ENABLED_DEFAULT = true
  
  # Tipos de criação de item habilitados no menu por padrão
  MENU_CRAFTING_TYPES_DEFAULT = []
  
end
  
#==============================================================================
# * Crafting::Sound
#------------------------------------------------------------------------------
#  Módulo de configuração de sons do script. Define os SEs usados na cena.
#==============================================================================

module Crafting::Sound
  # Sucesso
  SUCCESS = 'Applause1'
  
  # Falha
  FAILURE = 'Disappointment'
  
  # Item(ns) quebrado(s)
  BREAK = 'Break'
end

#==============================================================================
# * Crafting::Vocab
#------------------------------------------------------------------------------
#  Módulo de configuração de vocabulário do script. Define os termos e
# mensagens.
#==============================================================================

module Crafting::Vocab
  # Título da opção no menu
  MENU_OPTION = "Criação"
  
  # Rótulo da seção de materiais na cena
  MATERIALS = "Materiais"
  
  # Texto usado quando um item pode ser criado por um ator de qualquer classe
  ANY_CLASS = "Todos"
  
  # Taxa de Sucesso
  SUCCESS_RATE = "Taxa de Sucesso"
  
  # Taxa de Perda
  BREAK_RATE = "Taxa de Perda"
  
  # Texto de confirmação de forja
  CRAFT = "Criar"
  
  # Sucesso
  SUCCESS = "Sucesso"
  
  # Falha
  FAILURE = "Falha"
  
  # Item ganho
  GAINED_ITEM = "%<name>s +%<amount>d"
  
  # Item perdido
  LOST_ITEM = "%<name>s -%<amount>d"
  
  # Item quebrado
  BROKEN_ITEM = "%<name>s -%<amount>d"
end

#==============================================================================
# * Crafting
#------------------------------------------------------------------------------
#  Módulo principal do script. Tem funções úteis para interagir com os objetos
# do script.
#==============================================================================

module Crafting
  #--------------------------------------------------------------------------
  # * Variáveis
  #--------------------------------------------------------------------------
  @enabled_from_menu = Crafting::Config::CRAFT_FROM_MENU
  @menu_enabled = Crafting::Config::MENU_ENABLED_DEFAULT
  @menu_enabled_types = Crafting::Config::MENU_CRAFTING_TYPES_DEFAULT
  
  #--------------------------------------------------------------------------
  # * Prepara e chama a cena de criação
  #--------------------------------------------------------------------------
  def self.call(*types)
    SceneManager.call(scene)
    SceneManager.scene.prepare(types)
  end
  
  #--------------------------------------------------------------------------
  # * Prepara e chama a cena de criação pelo menu
  #--------------------------------------------------------------------------
  def self.call_from_menu
    SceneManager.call(scene)
    SceneManager.scene.prepare(@menu_enabled_types, false)
  end
  
  #--------------------------------------------------------------------------
  # * Obtém a classe da cena de criação
  #--------------------------------------------------------------------------
  def self.scene
    Scene_Crafting
  end
  
  #--------------------------------------------------------------------------
  # * Verifica liberação da criação pelo menu
  #--------------------------------------------------------------------------
  def self.enabled_from_menu?
    @enabled_from_menu
  end
  
  #--------------------------------------------------------------------------
  # * Libera a criação pelo menu
  #--------------------------------------------------------------------------
  def self.enable_from_menu
    @enabled_from_menu = true
  end
  
  #--------------------------------------------------------------------------
  # * Bloqueia a criação pelo menu
  #--------------------------------------------------------------------------
  def self.disable_from_menu
    @enabled_from_menu = false
  end
  
  #--------------------------------------------------------------------------
  # * Estado da opção do menu
  #--------------------------------------------------------------------------
  def self.menu_enabled
    @menu_enabled && !@menu_enabled_types.empty?
  end
  
  #--------------------------------------------------------------------------
  # * Define o estado da opção do menu
  #--------------------------------------------------------------------------
  def self.menu_enabled=(enabled)
    @menu_enabled = enabled
  end
  
  #--------------------------------------------------------------------------
  # * Habilita tipos de criação no menu
  #--------------------------------------------------------------------------
  def self.menu_enable_types(*types)
    @menu_enabled_types += types
    @menu_enabled_types.uniq!
  end
  
  #--------------------------------------------------------------------------
  # * Desabilita tipos de criação no menu
  #--------------------------------------------------------------------------
  def self.menu_disable_types(*types)
    @menu_enabled_types -= types
  end
  
  #--------------------------------------------------------------------------
  # * Lista de dados de itens forjáveis
  #--------------------------------------------------------------------------
  def self.data_craftable_items
    @data_craftable_items ||= Data_CraftableItems.new
  end
  
  #--------------------------------------------------------------------------
  # * Lista de objetos de itens forjáveis
  #--------------------------------------------------------------------------
  def self.game_craftable_items
    @game_craftable_items ||= Game_CraftableItems.new
  end
end

#==============================================================================
# * Crafting::CraftableItem
#------------------------------------------------------------------------------
#  Classe de dados para itens que podem ser forjados. Serve como decorador para
# as classes de item padrão do RGSS.
#==============================================================================

class Crafting::CraftableItem
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :item         # RPG::Item, RPG::Weapon ou RPG::Armor
  attr_accessor :type         # Tipo de forja (Básica, Mágica, etc.)
  attr_accessor :level        # Nível necessário (1, 0..5, 3...20, etc.)
  attr_accessor :materials    # Materiais necessários para a forja
  attr_accessor :success_rate # Taxa de sucesso (0 a 1)
  attr_accessor :break_rate   # Taxa de quebra do item (após falha, 0 a 1)
  attr_accessor :class_id     # ID da classe necessária para criar o item
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(item, type, level, materials, success_rate, break_rate,
      class_id)
    @item = item
    @type = type
    @level = level
    @materials = materials
    @success_rate = success_rate
    @break_rate = break_rate
    @class_id = class_id
  end
end

#==============================================================================
# * Crafting::Material
#------------------------------------------------------------------------------
#  Classe de dados para materiais de forja.
#==============================================================================

class Crafting::Material
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :item   # RPG::Item, RPG::Weapon ou RPG::Armor
  attr_accessor :amount # Quantidade
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(item, amount)
    @item = item
    @amount = amount
  end
end
  
#==============================================================================
# * Crafting::NoteParser_Item
#------------------------------------------------------------------------------
#  Classe para processador das notas de itens. Responsável por validar e
# extrair as informações que definem os parâmetros de forja para um item.
#==============================================================================

class Crafting::NoteParser_Item  
  #--------------------------------------------------------------------------
  # * Constantes (Expressões regulares)
  #--------------------------------------------------------------------------
  CRAFTABLE_REGEXP  = /[craftable]/i
  FIELD_REGEXP      = '%<name>s\s*=\s*(?<value>.*)'
  RANGE_REGEXP      = /(\d+)(\.{2,3})(\d+)/
  MATERIAL_REGEXP   = /(?<type>I|A|W)(?<id>\d+)(?:\*(?<amount>\d+))?/i
  RATE_REGEXP       = /(\d+(?:\.\d+)?|\.\d+)(%)?/
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     item  : Item do banco de dados
  #--------------------------------------------------------------------------
  def initialize(item)
    @item = item
    @note = @item.note
    @start = @note.index(CRAFTABLE_REGEXP)
    @start = @note.index("\n", @start) + 1 if valid?
  end
  
  #--------------------------------------------------------------------------
  # * Determina se o item passado é válido para forja
  #--------------------------------------------------------------------------
  def valid?
    !@start.nil?
  end
  
  #--------------------------------------------------------------------------
  # * Processa as notas do item e retorna informações de forja
  #--------------------------------------------------------------------------
  def parse
    Crafting::CraftableItem.new(
      @item,
      parse_field('Type').downcase.to_sym,
      parse_level,
      parse_materials,
      parse_rate('Rate'),
      parse_rate('Break', 0),
      parse_integer('Class')
    )
  end
  
  private
  
  #--------------------------------------------------------------------------
  # * Obtém o valor de um campo de configuração nas notas do item
  #     field : Campo a ser extraído
  #--------------------------------------------------------------------------
  def parse_field(field)
    regexp = Regexp.compile(sprintf(FIELD_REGEXP, { name: field }), true)
    return nil if @note.index(regexp, @start).nil?
    
    Regexp.last_match(:value).strip
  end
  
  #--------------------------------------------------------------------------
  # * Obtém o nível necessário para a forja
  #--------------------------------------------------------------------------
  def parse_level
    value = parse_field('Level')
    return 1 if value.nil?
    
    if value =~ RANGE_REGEXP
      return Range.new($1.to_i, $3.to_i, $2.size == 3)
    end
    
    Integer(value)
  end
  
  #--------------------------------------------------------------------------
  # * Obtém os materiais necessários para a forja
  #--------------------------------------------------------------------------
  def parse_materials
    value = parse_field('Materials')
    return [] if value.nil?
    
    value.split(',').map do |part|
      parse_single_material(part)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Processa uma especificação de material
  #--------------------------------------------------------------------------
  def parse_single_material(note)
    unless note =~ MATERIAL_REGEXP
      raise "Invalid crafting material specification `#{note}'"
    end
    
    match = Regexp.last_match

    type = match[:type]
    id = match[:id].to_i
    
    item = item_of(type, id)
    amount = match[:amount] || 1
    
    Crafting::Material.new(item, amount.to_i)
  end
  
  #--------------------------------------------------------------------------
  # * Obtém um item dado um identificador de tipo e ID
  #--------------------------------------------------------------------------
  def item_of(type, id)
    case type.upcase
    when 'I'
      $data_items[id]
    when 'A'
      $data_armors[id]
    when 'W'
      $data_weapons[id]
    end
  end
  
  #--------------------------------------------------------------------------
  # * Obtém o valor de uma configuração de taxa
  #--------------------------------------------------------------------------
  def parse_rate(field, default = 1.0)
    value = parse_field(field)
    return default if value.nil?
    
    unless value =~ RATE_REGEXP
      raise "Invalid rate specification `#{value}'"
    end
    
    r = Float($1)
    r *= 0.01 unless $2.nil?
    r
  end

  #--------------------------------------------------------------------------
  # * Obtém o valor de uma configuração numérica inteira
  #--------------------------------------------------------------------------
  def parse_integer(field)
    value = parse_field(field)
    return nil if value.nil?
    
    Integer(value)
  end
end

#==============================================================================
# ** Crafting::Data_CraftableItems
#------------------------------------------------------------------------------
#  Classe para a lista de dados de itens que podem ser forjados. A instância
# dessa classe pode ser acessada como Crafting.data_craftable_items.
#==============================================================================

class Crafting::Data_CraftableItems
  include Enumerable
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @data = {
      RPG::Item => {},
      RPG::Weapon => {},
      RPG::Armor => {}
    }
    load
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de um objeto dado um tipo e um id
  #     type  : RPG::Item, RPG::Weapon ou RPG::Armor
  #     id    : ID do objeto
  #--------------------------------------------------------------------------
  def [](type, id)
    @data[type][id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de um item para um id
  #     id  : ID do item no banco de dados
  #--------------------------------------------------------------------------
  def item(id)
    self[RPG::Item, id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de uma arma para um id
  #     id  : ID da arma no banco de dados
  #--------------------------------------------------------------------------
  def weapon(id)
    self[RPG::Weapon, id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de uma armadura para um id
  #     id  : ID da armadura no banco de dados
  #--------------------------------------------------------------------------
  def armor(id)
    self[RPG::Armor, id]
  end
  
  #--------------------------------------------------------------------------
  # * Percorre os índices da lista
  #--------------------------------------------------------------------------
  def each_index
    @data.each do |type, type_data|
      type_data.each_key do |id|
        yield [type, id]
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Percorre a lista
  #--------------------------------------------------------------------------
  def each(&block)
    @data.each_value do |type_data|
      type_data.each_value(&block)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Tamanho da lista
  #--------------------------------------------------------------------------
  def size
    @data.size
  end
  
  private
  
  #--------------------------------------------------------------------------
  # * Carregamento dos dados
  #--------------------------------------------------------------------------
  def load
    all_items.each do |item|
      parser = Crafting::NoteParser_Item.new(item)
      next unless parser.valid?
      
      @data[item.class][item.id] = parser.parse
    end
  end
  
  #--------------------------------------------------------------------------
  # * Enumerador para os objetos de dados de itens que podem ser forjados
  #--------------------------------------------------------------------------
  def all_items
    Enumerator.new do |enum|
      $data_items.compact.each    { |i| enum << i }
      $data_weapons.compact.each  { |i| enum << i }
      $data_armors.compact.each   { |i| enum << i }
    end
  end
end

#==============================================================================
# ** Crafting::Game_CraftingResult
#------------------------------------------------------------------------------
#  Classe base para um resultado de tentativa de forja. Esse objeto indica se a
# tentativa foi bem sucedida e, se não, quais itens foram perdidos e/ou ganhos.
#==============================================================================

class Crafting::Game_CraftingResult
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :gained_items
  attr_reader :used_items
  attr_reader :broken_items
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     item  : Game_CraftableItem
  #--------------------------------------------------------------------------
  def initialize(item)
    @item = item
    @gained_items = make_gained_items
    @used_items = make_used_items
    @broken_items = make_broken_items
  end
  
  #--------------------------------------------------------------------------
  # * Verifica se a tentativa foi bem sucedida
  #--------------------------------------------------------------------------
  def success?
    false
  end
  
  #--------------------------------------------------------------------------
  # * Aplicação o resultado
  #--------------------------------------------------------------------------
  def apply
    gained_items.each do |item, amount|
      $game_party.gain_item(item, amount)
    end
    
    lost_items.each do |item, amount|
      $game_party.lose_item(item, amount)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens ganhos
  #--------------------------------------------------------------------------
  def make_gained_items
    []
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens quebrados
  #--------------------------------------------------------------------------
  def make_broken_items
    []
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens usados
  #--------------------------------------------------------------------------
  def make_used_items
    []
  end
  
  #--------------------------------------------------------------------------
  # * Lista de itens perdidos
  #--------------------------------------------------------------------------
  def lost_items
    used_items + broken_items
  end
end

#==============================================================================
# ** Crafting::Game_CraftingSuccess
#------------------------------------------------------------------------------
#  Classe de resultado para criação bem sucedida de um item.
#==============================================================================

class Crafting::Game_CraftingSuccess < Crafting::Game_CraftingResult
  #--------------------------------------------------------------------------
  # * Verifica se a tentativa foi bem sucedida
  #--------------------------------------------------------------------------
  def success?
    true
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens ganhos
  #--------------------------------------------------------------------------
  def make_gained_items
    [[@item.item, 1]]
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens usados
  #--------------------------------------------------------------------------
  def make_used_items
    @item.materials.map do |material|
      [material.item, material.amount]
    end
  end
end

#==============================================================================
# ** Crafting::Game_CraftingFailure
#------------------------------------------------------------------------------
#  Classe de resultado para falha na criação de um item.
#==============================================================================

class Crafting::Game_CraftingFailure < Crafting::Game_CraftingResult
  #--------------------------------------------------------------------------
  # * Construção da lista de itens usados
  #--------------------------------------------------------------------------
  def make_used_items
    @item.materials.map do |material|
      next unless material.item.is_a?(RPG::Item)
      
      [material.item, material.amount]
    end.compact
  end
  
  #--------------------------------------------------------------------------
  # * Construção da lista de itens quebrados
  #--------------------------------------------------------------------------
  def make_broken_items
    @item.materials.map do |material|
      next unless material.item.is_a?(RPG::EquipItem)
      
      amount = calc_broken_amount(material)
      next if amount.zero?
      
      [material.item, amount]
    end.compact
  end
  
  private
  
  #--------------------------------------------------------------------------
  # * Cálculo da quantidade perdida de um determinado material quebrável
  #     material  : Material
  #--------------------------------------------------------------------------
  def calc_broken_amount(material)
    amount = 0
    material.amount.times do
      amount += 1 if rand <= @item.craftable_item.break_rate
    end
    
    amount
  end
end

#==============================================================================
# ** Crafting::Game_CraftableItem
#------------------------------------------------------------------------------
#  Classe para um item que pode ser forjado. Enquanto os objetos de dados
# armazenam as informações sobre um item, essa classe tem os métodos que
# controlam a lógica da forja no jogo. 
#==============================================================================

class Crafting::Game_CraftableItem
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :craftable_item
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     craftable_item  : Crafting::CraftableItem
  #--------------------------------------------------------------------------
  def initialize(craftable_item)
    @craftable_item = craftable_item
  end
  
  #--------------------------------------------------------------------------
  # * Determina se o item pode ser construído por um ator
  #     actor : Game_Actor
  #--------------------------------------------------------------------------
  def craftable?(actor)
    return false if actor.level < @craftable_item.level
    
    if !@craftable_item.class_id.nil?
      return false unless actor.class_id == @craftable_item.class_id
    end
    
    enough_materials?
  end
  
  #--------------------------------------------------------------------------
  # * Objeto de dados do item
  #--------------------------------------------------------------------------
  def item
    @craftable_item.item
  end
  
  #--------------------------------------------------------------------------
  # * Materiais do item
  #--------------------------------------------------------------------------
  def materials
    @craftable_item.materials
  end
  
  #--------------------------------------------------------------------------
  # * Lista dos materiais que são equipamentos
  #--------------------------------------------------------------------------
  def equip_materials
    materials.select { |material| material.item.is_a?(RPG::EquipItem) }
  end
  
  #--------------------------------------------------------------------------
  # * Determina se o grupo tem materiais suficientes
  #--------------------------------------------------------------------------
  def enough_materials?
    @craftable_item.materials.all? do |material|
      $game_party.item_number(material.item) >= material.amount
    end
  end
  
  #--------------------------------------------------------------------------
  # * Calcula uma tentativa de criar o item
  #--------------------------------------------------------------------------
  def try_craft
    if rand <= @craftable_item.success_rate
      Crafting::Game_CraftingSuccess.new(self)
    else
      Crafting::Game_CraftingFailure.new(self)      
    end
  end
end

#==============================================================================
# ** Crafting::Game_CraftableItems
#------------------------------------------------------------------------------
#  Classe para a lista de itens que podem ser forjados. A instância dessa
# classe pode ser acessada como Crafting.game_craftable_items.
#==============================================================================

class Crafting::Game_CraftableItems
  include Enumerable
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @data = {
      RPG::Item => {},
      RPG::Weapon => {},
      RPG::Armor => {}
    }
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de um objeto dado um tipo e um id
  #     type  : RPG::Item, RPG::Weapon ou RPG::Armor
  #     id    : ID do objeto
  #--------------------------------------------------------------------------
  def [](type, id)
    unless @data[type].key?(id)
      craftable_item = Crafting.data_craftable_items[type, id]
      @data[type][id] = Crafting::Game_CraftableItem.new(craftable_item)
    end
    
    @data[type][id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de um item para um id
  #     id  : ID do item no banco de dados
  #--------------------------------------------------------------------------
  def item(id)
    self[RPG::Item, id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de uma arma para um id
  #     id  : ID da arma no banco de dados
  #--------------------------------------------------------------------------
  def weapon(id)
    self[RPG::Weapon, id]
  end
  
  #--------------------------------------------------------------------------
  # * Leitura de uma armadura para um id
  #     id  : ID da armadura no banco de dados
  #--------------------------------------------------------------------------
  def armor(id)
    self[RPG::Armor, id]
  end
  
  #--------------------------------------------------------------------------
  # * Percorre a lista
  #--------------------------------------------------------------------------
  def each(&block)
    Crafting.data_craftable_items.each_index do |type, id|
      yield self[type, id]
    end
  end
  
  #--------------------------------------------------------------------------
  # * Tamanho da lista
  #--------------------------------------------------------------------------
  def size
    Crafting.data_craftable_items.size
  end
end

#==============================================================================
# ** Crafting::Window_CraftingActor
#------------------------------------------------------------------------------
#  Esta janela controla a seleção do ator para a cena de forja.
#==============================================================================

class Crafting::Window_CraftingActor < Window_Selectable
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, window_width, window_height)
    refresh
    select(0)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da largura da janela
  #--------------------------------------------------------------------------
  def window_width
    Graphics.width
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da altura da janela
  #--------------------------------------------------------------------------
  def window_height
    fitting_height(4)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do número máximo de itens
  #--------------------------------------------------------------------------
  def item_max
    $game_party.members.size
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do número máximo de colunas
  #--------------------------------------------------------------------------
  def col_max
    (width + spacing) / (item_width + spacing)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da largura os itens
  #--------------------------------------------------------------------------
  def item_width
    220
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição de altura do item
  #--------------------------------------------------------------------------
  def item_height
    height - standard_padding * 2
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do espaçamento entre os itens
  #--------------------------------------------------------------------------
  def spacing
    return 8
  end
  
  #--------------------------------------------------------------------------
  # * Cálculo da altura do conteúdo da janela
  #--------------------------------------------------------------------------
  def contents_width
    (item_width + spacing) * item_max - spacing
  end
  
  #--------------------------------------------------------------------------
  # * Cálculo da altura do conteúdo da janela
  #--------------------------------------------------------------------------
  def contents_height
    item_height
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da primeira coluna
  #--------------------------------------------------------------------------
  def top_col
    @top_col ||= 0
  end
  
  #--------------------------------------------------------------------------
  # * Definição da primeira coluna
  #     col : coluna
  #--------------------------------------------------------------------------
  def top_col=(col)
    col = 0 if col < 0
    col = item_max - 1 if col > item_max - 1
    @top_col = col
    self.ox = [col * (item_width + spacing), ox_max].min
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do offset horizontal máximo
  #--------------------------------------------------------------------------
  def ox_max
    contents_width - (width - standard_padding * 2)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da última coluna
  #--------------------------------------------------------------------------
  def bottom_col
    top_col + col_max - 1
  end
  
  #--------------------------------------------------------------------------
  # * Definição da última coluna
  #     col : coluna
  #--------------------------------------------------------------------------
  def bottom_col=(col)
    self.top_col = col - (col_max - 1)
  end
  
  #--------------------------------------------------------------------------
  # * Confirmação de visibilidade do cursor
  #--------------------------------------------------------------------------
  def ensure_cursor_visible
    self.top_col = index if index < top_col
    self.bottom_col = index if index > bottom_col
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do retangulo para desenhar o item
  #     index : índice do item
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super
    rect.x = index * (item_width + spacing)
    rect.y = 0
    rect
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um item
  #     index : índice do item
  #--------------------------------------------------------------------------
  def draw_item(index)
    actor = $game_party.members[index]
    rect = item_rect(index)
    draw_actor_face(actor, rect.x + 1, rect.y)
    rect.x += 108
    draw_actor_name(actor, rect.x, rect.y)
    draw_actor_class(actor, rect.x, rect.y + line_height * 1)
    draw_actor_level(actor, rect.x, rect.y + line_height * 2)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do ator selecionado para a janela
  #--------------------------------------------------------------------------
  def actor
    $game_party.members[index]
  end
end

#==============================================================================
# ** Crafting::Window_CraftingItemInfo
#------------------------------------------------------------------------------
#  Classe base para janelas que mostram as informações de um item escolhido
# para criação.
#==============================================================================

class Crafting::Window_CraftingItemInfo < Window_Base
  #--------------------------------------------------------------------------
  # * Aquisição do ator selecionado para a janela
  #--------------------------------------------------------------------------
  def actor=(actor)
    @actor = actor
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Define o item para o qual mostrar os materiais
  #     item  : CraftableItem
  #--------------------------------------------------------------------------
  def set_item(item)
    @item = item
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    return if @item.nil? || @actor.nil?
    
    refresh_contents
  end
  
  #--------------------------------------------------------------------------
  # * Renovação do conteúdo
  #--------------------------------------------------------------------------
  def refresh_contents
    draw_header(0)
    draw_horz_line(line_height)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho do cabeçalho
  #--------------------------------------------------------------------------
  def draw_header(y)
    draw_item_name(@item.item, 0, y, true, width)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de uma linha horzontal
  #--------------------------------------------------------------------------
  def draw_horz_line(y)
    line_y = y + line_height / 2 - 1
    contents.fill_rect(0, line_y, contents_width, 2, line_color)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisção da cor da linha horizontal
  #--------------------------------------------------------------------------
  def line_color
    color = normal_color
    color.alpha = 48
    color
  end
end

#==============================================================================
# ** Crafting::Window_Materials
#------------------------------------------------------------------------------
#  Esta janela exibe a lista de requisitos para a criação de um item, como
# class, nível, materiais, etc. Infelizmente, não consegui pensar em um nome
# melhor.
#==============================================================================

class Crafting::Window_Materials < Crafting::Window_CraftingItemInfo
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh_contents
    super
    draw_class(line_height * 2)
    draw_min_level(line_height * 3)
    draw_horz_line(line_height * 4)
    draw_materials(line_height * 5)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho do nível mínimo necessário
  #--------------------------------------------------------------------------
  def draw_min_level(y)
    if @actor.level < @item.level
      color1 = crisis_color
      change_color(unsatisfied_color)
    else
      color1 = normal_color
      change_color(system_color)
    end
    draw_text(0, y, width / 2, line_height, Vocab.level)
    draw_current_and_max_values(contents_width - 96, y, 96, @actor.level,
      @item.level, color1, normal_color)
    end
    
  #--------------------------------------------------------------------------
  # * Desenho da classe necessária
  #--------------------------------------------------------------------------
  def draw_class(y)    
    if !@item.class_id.nil? && @actor.class_id != @item.class_id
      change_color(crisis_color)
    end
    
    class_name = @item.class_id.nil? ? Crafting::Vocab::ANY_CLASS :
      $data_classes[@item.class_id].name
    
    draw_text(0, y, width / 2, line_height, class_name)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho dos materiais
  #--------------------------------------------------------------------------
  def draw_materials(y)
    label_color = system_color
    @item.materials.each_with_index do |material, i|
      iy = y + (i + 1) * line_height
      draw_item_name(material.item, 0, iy, true, contents_width - 96)
      
      amount = $game_party.item_number(material.item)
      if amount < material.amount
        label_color = unsatisfied_color
        color1 = crisis_color
      else
        color1 = normal_color
      end
      
      draw_current_and_max_values(contents_width - 96, iy, 96, amount,
        material.amount, color1, normal_color)
    end
      
    change_color(label_color)
    draw_text(0, y, width, line_height, Crafting::Vocab::MATERIALS)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da cor para condição não satisfeita
  #--------------------------------------------------------------------------
  def unsatisfied_color
    crisis_color
  end
end

#==============================================================================
# ** Crafting::Window_CraftableItems
#------------------------------------------------------------------------------
#  Esta janela lista os itens que podem ser forjados na tela de forja.
#==============================================================================

class Crafting::Window_CraftableItems < Window_Selectable
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     x       : coordenada X
  #     y       : coordenada Y
  #     width   : largura
  #     height  : altura
  #     types   : filtro de tipos de item
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, types)
    @data = Crafting.game_craftable_items.select do |item|
      types.include?(item.craftable_item.type)
    end.to_a
    super(x, y, width, height)
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Define a janela de lista de materiais
  #     window  : Window_CraftingMaterials
  #--------------------------------------------------------------------------
  def materials_window=(window)
    @materials_window = window
    @materials_window.actor = @actor
    update_materials
  end
  
  #--------------------------------------------------------------------------
  # * Define a janela de informações do item
  #     window  : Window_CraftingItemInfo
  #--------------------------------------------------------------------------
  def item_info_window=(window)
    @item_details_window = window
    @item_details_window.actor = @actor
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição das informações do item selecionado
  #--------------------------------------------------------------------------
  def craftable_item
    @data[index]
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do número máximo de itens
  #--------------------------------------------------------------------------
  def item_max
    @data.size
  end
  
  #--------------------------------------------------------------------------
  # * Definição do ator selecionado para a janela
  #--------------------------------------------------------------------------
  def actor=(actor)
    @actor = actor
    @materials_window.actor = @actor if @materials_window
    @item_details_window.actor = @actor if @item_details_window
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Determina se um item está habilitado
  #     index : Índice do item
  #--------------------------------------------------------------------------
  def enable?(index)
    return false if @actor.nil?
    
    @data[index].craftable?(@actor)
  end
  
  #--------------------------------------------------------------------------
  # * Definição de habilitação de seleção
  #--------------------------------------------------------------------------
  def current_item_enabled?
    enable?(index)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um item
  #     index : índice do item
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index].item
    rect = item_rect(index)
    draw_item_name(item, rect.x, rect.y, enable?(index), width)
  end
  
  #--------------------------------------------------------------------------
  # * Atualização da janela de ajuda
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(@data[index].item) if @help_window
    update_materials
  end
  
  #--------------------------------------------------------------------------
  # * Atualização da janela de materiais
  #--------------------------------------------------------------------------
  def update_materials
    if @materials_window
      @materials_window.set_item(@data[index].craftable_item)
    end
    
    if @item_details_window
      @item_details_window.set_item(@data[index].craftable_item)
    end
  end
end

#==============================================================================
# ** Crafting::Window_CraftingItemDetails
#------------------------------------------------------------------------------
#  Esta janela mostra os detalhes de um equipamento escolhido para forja, como
# taxas de sucesso e perda. Para equipamentos, mostra também os atributos.
#==============================================================================

class Crafting::Window_CraftingItemDetails < Crafting::Window_CraftingItemInfo
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh_contents
    super
    draw_success_rate(line_height * 2)
    draw_break_rate(line_height * 3)
    if @item.item.is_a?(RPG::EquipItem)
      draw_horz_line(line_height * 4)
      draw_item_params(line_height * 5)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Desenho da taxa de sucesso
  #--------------------------------------------------------------------------
  def draw_success_rate(y)
    change_color(system_color)
    draw_text(0, y, 150, line_height, Crafting::Vocab::SUCCESS_RATE)
    change_color(normal_color)
    draw_text(150, y, contents_width - 150, line_height,
      sprintf('%.1f%%', @item.success_rate * 100), 2)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho da taxa de perda
  #--------------------------------------------------------------------------
  def draw_break_rate(y)
    change_color(system_color)
    draw_text(0, y, 150, line_height, Crafting::Vocab::BREAK_RATE)
    change_color(normal_color)
    draw_text(150, y, contents_width - 150, line_height,
      sprintf('%.1f%%', (1 - @item.success_rate) * @item.break_rate * 100), 2)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho da taxa de sucesso
  #--------------------------------------------------------------------------
  def draw_item_params(y)
    for i in 0..7
      change_color(system_color)
      draw_text(0, y, 180, line_height, Vocab.param(i))
      change_color(normal_color)
      draw_text(180, y, contents_width - 180, line_height,
        @item.item.params[i], 2)
      y += line_height
    end
  end
end

#==============================================================================
# ** Crafting::Window_CraftingConfirm
#------------------------------------------------------------------------------
#  Janela de confirmação de criação de item.
#==============================================================================

class Crafting::Window_CraftingConfirm < Window_Command
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     x      : coordenada X
  #     y      : coordenada Y
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super
    self.openness = 0
  end
  
  #--------------------------------------------------------------------------
  # * Criação da lista de comandos
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(Crafting::Vocab::CRAFT, :ok)
    add_command(Vocab.cancel, :cancel)
  end
end

#==============================================================================
# ** Crafting::Window_CraftingResult
#------------------------------------------------------------------------------
#  Janela de resultado de criação de item.
#==============================================================================

class Crafting::Window_CraftingResult < Window_Base
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    super
    @handler = nil
    @result = nil
    self.pause = true
    self.openness = 0
  end
  
  #--------------------------------------------------------------------------
  # * Atualização da tela
  #--------------------------------------------------------------------------
  def update
    super
    return unless open? && active
    
    @handler.call if Input.trigger?(:B) || Input.trigger?(:C)
  end
  
  #--------------------------------------------------------------------------
  # * Definição do resultado
  #--------------------------------------------------------------------------
  def result=(result)
    @result = result
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Definição do procedimento após confirmação
  #--------------------------------------------------------------------------
  def set_handler(handler)
    @handler = handler
  end
  
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    if @result.success?
      draw_success
    else
      draw_failure
    end
    draw_result
  end
  
  #--------------------------------------------------------------------------
  # * Desenho das informações de sucesso
  #--------------------------------------------------------------------------
  def draw_success
    change_color(text_color(3))
    draw_text(0, 0, contents_width, line_height, Crafting::Vocab::SUCCESS)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho das informações de falha
  #--------------------------------------------------------------------------
  def draw_failure
    change_color(text_color(2))
    draw_text(0, 0, contents_width, line_height, Crafting::Vocab::FAILURE)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho dos resultados
  #--------------------------------------------------------------------------
  def draw_result
    change_color(normal_color)
    
    y = line_height * 2
    
    @result.gained_items.each do |item, amount|
      draw_gained_item(y, item, amount)
      y += line_height
    end
    
    @result.used_items.each do |item, amount|
      draw_used_item(y, item, amount)
      y += line_height
    end
    
    @result.broken_items.each do |item, amount|
      draw_broken_item(y, item, amount)
      y += line_height
    end
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de uma linha de item
  #--------------------------------------------------------------------------
  def draw_item_line(y, format, item, amount, icon_enabled = true)
    draw_icon(item.icon_index, 0, y, icon_enabled)
    line = format_line(format, item, amount)
    draw_text(28, y, width - 28, line_height, line)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um item ganho
  #--------------------------------------------------------------------------
  def draw_gained_item(y, item, amount)
    draw_item_line(y, Crafting::Vocab::GAINED_ITEM, item, amount)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um item usado
  #--------------------------------------------------------------------------
  def draw_used_item(y, item, amount)
    draw_item_line(y, Crafting::Vocab::LOST_ITEM, item, amount, false)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um item perdido
  #--------------------------------------------------------------------------
  def draw_broken_item(y, item, amount)
    draw_item_line(y, Crafting::Vocab::BROKEN_ITEM, item, amount, false)
  end
    
  private
  
  #--------------------------------------------------------------------------
  # * Formatação de linha de item ganho/perdido
  #--------------------------------------------------------------------------
  def format_line(line_format, item, amount)
    sprintf(line_format, {
      name: item.name,
      amount: amount
    })
  end
end

#==============================================================================
# ** Crafting::Scene_Crafting
#------------------------------------------------------------------------------
#  Classe para a cena de forja.
#==============================================================================

class Crafting::Scene_Crafting < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Preparação
  #--------------------------------------------------------------------------
  def prepare(types, pick_actor = true)
    @types = types.map(&:downcase).map(&:to_sym)
    @pick_actor = pick_actor
  end
  
  #--------------------------------------------------------------------------
  # * Inicialização da cena
  #--------------------------------------------------------------------------
  def start
    super
    create_actor_window if @pick_actor
    create_help_window
    create_items_window
    create_materials_window
    create_item_info_window
    create_confirm_window
    create_result_window
    update_all_windows
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de atores
  #--------------------------------------------------------------------------
  def create_actor_window
    @actor_window = Crafting::Window_CraftingActor.new
    @actor_window.z = 200
    @actor_window.select(0)
    @actor_window.activate
    @actor_window.set_handler(:ok, method(:on_actor_ok))
    @actor_window.set_handler(:cancel, method(:return_scene))
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de itens
  #--------------------------------------------------------------------------
  def create_items_window
    x = 0
    y = @help_window.y + @help_window.height
    width = Graphics.width / 2
    height = Graphics.height - y
    @items_window = Crafting::Window_CraftableItems.new(x, y, width, height,
      @types)
    @items_window.set_handler(:ok, method(:on_craft_ok))
    @items_window.set_handler(:cancel, method(:on_craft_cancel))
    @items_window.help_window = @help_window
    unless @pick_actor
      @items_window.select(0)
      @items_window.activate
      @items_window.actor = @actor
    end
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de materiais
  #--------------------------------------------------------------------------
  def create_materials_window
    x = @items_window.width
    y = @help_window.y + @help_window.height
    width = Graphics.width - x
    height = Graphics.height - y
    @materials_window = Crafting::Window_Materials.new(x, y, width, height)
    @items_window.materials_window = @materials_window
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de informações de item
  #--------------------------------------------------------------------------
  def create_item_info_window
    x = @items_window.width
    y = @help_window.y + @help_window.height
    width = Graphics.width - x
    height = Graphics.height - y
    @item_details_window = Crafting::Window_CraftingItemDetails.new(x, y,
      width, height)
    @item_details_window.hide
    @items_window.item_info_window = @item_details_window
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de confirmação
  #--------------------------------------------------------------------------
  def create_confirm_window
    x = 0
    y = @help_window.y + @help_window.height
    @confirm_window = Crafting::Window_CraftingConfirm.new(x, y)
    @confirm_window.set_handler(:ok, method(:on_confirm_ok))
    @confirm_window.set_handler(:cancel, method(:on_confirm_cancel))
  end
  
  #--------------------------------------------------------------------------
  # * Criação da janela de resultado
  #--------------------------------------------------------------------------
  def create_result_window
    x = @items_window.width
    y = @help_window.y + @help_window.height
    width = Graphics.width - x
    height = Graphics.height - y
    @result_window = Crafting::Window_CraftingResult.new(x, y, width, height)
    @result_window.z = 200
    @result_window.set_handler(method(:on_result_ok))
  end
  
  #--------------------------------------------------------------------------
  # * Ator [Confirmação]
  #--------------------------------------------------------------------------
  def on_actor_ok
    @actor = @actor_window.actor
    on_actor_change
    @actor_window.close
    @actor_window.deactivate
    @items_window.select(0)
    @items_window.activate
  end
  
  #--------------------------------------------------------------------------
  # * Forja [Confirmação]
  #--------------------------------------------------------------------------
  def on_craft_ok
    @items_window.close
    @confirm_window.select(0)
    @confirm_window.open
    @confirm_window.activate
    @materials_window.hide
    @item_details_window.show
  end
  
  #--------------------------------------------------------------------------
  # * Forja [Cancelamento]
  #--------------------------------------------------------------------------
  def on_craft_cancel
    return return_scene unless @pick_actor
    
    @items_window.unselect
    @actor_window.open
    @actor_window.activate
    @actor = nil
    on_actor_change
  end
  
  #--------------------------------------------------------------------------
  # * Confirmação [Confirmação]
  #--------------------------------------------------------------------------
  def on_confirm_ok
    @confirm_window.close
    @item_details_window.hide
    do_crafting
  end
  
  #--------------------------------------------------------------------------
  # * Confirmação [Cancelamento]
  #--------------------------------------------------------------------------
  def on_confirm_cancel
    @confirm_window.close
    @items_window.open
    @items_window.activate
    @materials_window.show
    @item_details_window.hide
  end
  
  #--------------------------------------------------------------------------
  # * Resultado [Confirmação]
  #--------------------------------------------------------------------------
  def on_result_ok
    @result_window.hide
    @result_window.close
    @materials_window.show
    @items_window.open
    @items_window.select(0)
    @items_window.activate
  end
  
  #--------------------------------------------------------------------------
  # * Processo da mudança de herói
  #--------------------------------------------------------------------------
  def on_actor_change
    @items_window.actor = @actor
  end
  
  #--------------------------------------------------------------------------
  # * Execução da criação de item
  #--------------------------------------------------------------------------
  def do_crafting
    Audio.se_stop
    result = @items_window.craftable_item.try_craft
    result.apply
    on_result(result)
  end
  
  #--------------------------------------------------------------------------
  # * Tratamento de resultado da criação
  #--------------------------------------------------------------------------
  def on_result(result)
    @result_window.result = result
    @result_window.show
    @result_window.open
    if result.success?
      on_success
    else
      on_failure(result)
    end
    @items_window.refresh
  end
  
  #--------------------------------------------------------------------------
  # * Sucesso na criação
  #--------------------------------------------------------------------------
  def on_success
    RPG::SE.new(Crafting::Sound::SUCCESS).play
  end
  
  #--------------------------------------------------------------------------
  # * Falha na criação
  #--------------------------------------------------------------------------
  def on_failure(result)    
    if result.broken_items.empty?
      RPG::SE.new(Crafting::Sound::FAILURE).play
    else
      RPG::SE.new(Crafting::Sound::BREAK).play
    end
  end
end

#==============================================================================
# ** Window_MenuCommand
#------------------------------------------------------------------------------
#  Esta janela exibe os comandos do menu.
#==============================================================================

class Window_MenuCommand < Window_Command
  #--------------------------------------------------------------------------
  # * Adição dos comandos principais
  #--------------------------------------------------------------------------
  alias add_main_commands_without_crafting add_main_commands
  
  def add_main_commands
    add_main_commands_without_crafting
    return unless Crafting.enabled_from_menu?
    
    add_command(Crafting::Vocab::MENU_OPTION, :crafting, crafting_enabled)
  end
  
  #--------------------------------------------------------------------------
  # * Definição de habilitação de criação
  #--------------------------------------------------------------------------
  def crafting_enabled
    Crafting.menu_enabled
  end
end

#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de menu.
#==============================================================================

class Scene_Menu < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Criação da janela de comando
  #--------------------------------------------------------------------------
  alias create_command_window_without_crafting create_command_window
  
  def create_command_window
    create_command_window_without_crafting
    @command_window.set_handler(:crafting, method(:command_personal))
  end
  
  #--------------------------------------------------------------------------
  # * Comandos individuais [Confirmação]
  #--------------------------------------------------------------------------
  alias on_personal_ok_without_crafting on_personal_ok
  
  def on_personal_ok
    case @command_window.current_symbol
    when :crafting
      Crafting.call_from_menu
    else
      on_personal_ok_without_crafting
    end
  end
end