#===============================================================================
#
# Yanfly Engine RD - Actor Item Synthesis
# Last Date Updated: 2009.06.23
# Level: Hard
#
# This item synthesis script is influenced after Gust RPG's famous synthesizing
# systems. To synthesize an item, one would need a recipe and the required actor
# in your party. Different actors can yield different outcomes, but they all
# possess and use the same ingredients.
#
# Another thing this script will provide (for the player) is that any items that
# were synthesized through the shop's recipes can then be bought without need
# to synthesize them again. The need to constantly resynthesize items to get
# more of them becomes rather tedious and that really isn't something we should
# put the player through.
#
# This script also allows playing events after item creation similar to that of
# the Gust RPG's. There you can play out little skits and such or even unlock
# certain parts of the game for synthesizing a particular item.
#
#===============================================================================
# Updates:
# ----------------------------------------------------------------------------
# o 2009.06.23 - Compatibility fix with KGC Help Extension
# o 2009.06.21 - Compatibility update with Display Item Query
# o 2009.06.14 - Bug fix for Synth Listing
# o 2009.06.10 - Added <synth unbuyable>
# o 2009.06.04 - Added <synth block actor x>
#              - Common events are played only once per actor now
#              - Added <replay event> to replay common events more than once
#              - Added <synth exp x> and <synth exp x:y>
# o 2009.06.03 - Finished script
# o 2009.06.02 - Started script
#===============================================================================
# Instructions
#===============================================================================
#
# These go into the recipe's notebox. Recipes can be items, weapons, or armours
# but they must contain the following information before they can be recipes:
# -----------------------------------------------------------------------------
#
# <synth actor a b:c>
# a is the ID of the actor that can use the recipe. If the ID is 0, all actors
# can user the recipe. b has to be either I, W, or A. This will determine what
# type of item will be produced, an item, weapon, or armour. c is the ID of the
# item type to be created. <synth actor 3 I:8> means if actor 3 uses this recipe
# then actor 3 will create Item ID 8.
#
# <synth cost n>
# This is how much synthesizing the recipe will cost. If this isn't included,
# the synthesis is considered to be free.
#
# <ingredients a:b> or <ingredients a:b xc>
# This determines what ingredients are needed. a has to be either I, W, or A to
# determine what type of item is being used. b determines the item ID of the
# item type to be used. Should you decide to use the second tag, c is how many
# of the item is needed for the recipe to be made.
#
# -----------------------------------------------------------------------------
# The following are optional tags you may place in a recipe's notebox.
# -----------------------------------------------------------------------------
#
# <synth block actor x> or <synth block actor x,x>
# This will prevent actors from being able to perform the synthesis at all,
# even if actor 0 is listed for <synth actor>. To block multiple actors, just
# add more of the tags or use the <synth block actor x,x> version.
#
# <synth actor a event:b>
# For those that want to play a common event after a synthesis, set b to the ID
# of the common event desired. a is the actor set to play after that actor makes
# an item. If a is 0, it is set for all actors.
#
# <replay event>
# This will allow the common event to be replayable after viewing once.
#
# <consume recipe> or <not consume recipe>
# This will override the default rules set for consuming recipes. The first will
# always consume the recipe regardless of the rulesetting and the second one
# will prevent the recipe from being consumed.
#
# <synth exp x> or <synth exp x:y>
# This determines how much experience the actor synthesizing the item gains
# from performing the synthesis. The first time through, the actor will gain x
# experience. On follow-up synthesis sessions, the actor will not gain any exp
# unless the second tag is used. Only y exp will be gained on follow up any
# follow-up sessions. But no matter how much experience the actor gains, the
# actor cannot level up from synthesizing items (to prevent bugs from occuring).
#
# <synth unbuyable>
# This makes the item unable to be bought even after synthesizing it. This tag
# can be used in either the item to be bought or the recipe. If it's on the
# item to be bought, then only that item is is disabled from the recipe. If the
# tag is on the recipe, all items created by that recipe cannot be bought.
#
#===============================================================================
#
# Compatibility
# - Works With: KGC's LimitBreak, Help Extension
# - Works With: Yanfly's Variable Controlled Discounts
# - Alias: Scene_Map: call_shop
#
#===============================================================================

$imported = {} if $imported == nil
$imported["ActorItemSynthesis"] = true

module YE
  module SYNTH

    # This is the switch required to be on before the shop can be called out.
    # Remember to turn off your switches beforehand.
    SYNTH_SWITCH = 72

    # The following determines the various settings for the synthesis shop.
    SYNTH_TEXT   = "Synth"             # Synthesis option for shop commands.
    SYNTH_INCOMP = "Incompatible"      # Text for incompatible actors.
    SYNTH_INCOLR = 10                  # Colour for incompatible actors.
    SYNTH_INGRED = "Ingredients"       # Text used for ingredients.
    SYNTH_OUTCOM = "Outcome"           # Text used for ingredients.
    SYNTH_FSIZE  = 16                  # Font size for smaller text.
    SYNTH_OFFSET = 48                  # X offset for text next to actor sprite.
    SYNTH_TOTAL  = "Recipes Known: %d" # Total recipes done by actor.
    SYNTH_COST   = "Synth Cost"        # Text for synthesis cost.
    SYNTH_C_ICON = 205                 # Icon for synthesis cost.
    SYNTH_T_COST = "%d %s"             # Text format used for synth amount.
    SYNTH_AMT    = "%d/%d"             # Ingredients required over possessed.
    SYNTH_HIDE_0 = true                # This will hide amount needed if zero.
    SYNTH_UNICON = 144                 # Icon used for unknown items.
    SYNTH_UNMASK = "Unknown"           # Mask used for unknown items.

    # The following determines the rules for recipe consumption. This will
    # govern whether or not you would want recipes to be used up after synthing
    # an item. If it's set to true, recipes will be included in the ingredients
    # listing. The number consumed depends on how many items were synthesized
    # from the recipe.
    CONSUME_RECIPE_ITEM   = false  # If recipe is an item, consume item.
    CONSUME_RECIPE_WEAPON = true   # If recipe is an weapon, consume weapon.
    CONSUME_RECIPE_ARMOUR = true   # If recipe is an armour, consume armour.

    # The following determines the rules governing common events. Note that if
    # common events are played outside of the shop, the player will not return
    # to the shop after the event is done.
    EVENT_IN_SHOP = true    # Stay inside the shop for common events.
    FADE_TIME     = 30      # The amount of frames of fade in between events.

  end
end

#===============================================================================
# Editting anything past this point may potentially result in causing computer
# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.
# Therefore, edit at your own risk.
#===============================================================================

module YE
module REGEXP
module SYNTH

  ACTOR = /<(?:SYNTH_ACTOR|synth actor)[ ]*(\d+)[ ]\s*([IWA]):(\d+)?>/i
  EVENT = /<(?:SYNTH_ACTOR|synth actor)[ ]*(\d+)[ ](?:EVENT|event):(\d+)?>/i
  BLOCK = /<(?:SYNTH_BLOCK_ACTOR|synth block actor)[ ]*(\d+(?:\s*,\s*\d+)*)>/i
  COST  = /<(?:SYNTH_COST|synth cost)[ ]*(\d+)>/i
  INGRE = /<(?:INGREDIENT|ingredients)\s*([IWA]):(\d+)?>/i
  INGRX = /<(?:INGREDIENT|ingredients)\s*([IWA]):(\d+)[ ]x(\d+)?>/i
  CONSUME = /<(?:CONSUME|consume recipe)>/i
  NOTCONSUME = /<(?:NOT_CONSUME|not consume recipe|not consume)>/i
  REPLAY = /<(?:REPLAY_EVENT|replay event)>/i
  UNBUYABLE = /<(?:SYNTH_UNBUYABLE|synth unbuyable)>/i
  EXP1 = /<(?:SYNTH_EXP|synth exp)[ ]*(\d+)>/i
  EXP2 = /<(?:SYNTH_EXP|synth exp)[ ]*(\d+):(\d+)>/i

end # BASEITEM
end # REGEXP
end # YE

#===============================================================================
# RPG::BaseItem
#===============================================================================

class RPG::BaseItem

  #--------------------------------------------------------------------------
  # Yanfly_Cache_BaseItem_AIS
  #--------------------------------------------------------------------------
  def yanfly_cache_baseitem_ais
    @recipe = false; @synth_actor = {}; @ingredients = {}; @synth_cost = 0
    @synth_consume = false; @synth_event = {}; @synth_block = []
    @replay_event = false; @synth_exp1 = 0; @synth_exp2 = 0
    @synth_unbuyable = false

    self.note.split(/[\r\n]+/).each { |line|
      case line
      when YE::REGEXP::SYNTH::ACTOR
        case $2.upcase
        when "I"
          @synth_actor[$1.to_i] = $data_items[$3.to_i]
          @synth_consume = YE::SYNTH::CONSUME_RECIPE_ITEM
        when "W"
          @synth_actor[$1.to_i] = $data_weapons[$3.to_i]
          @synth_consume = YE::SYNTH::CONSUME_RECIPE_WEAPON
        when "A"
          @synth_actor[$1.to_i] = $data_armors[$3.to_i]
          @synth_consume = YE::SYNTH::CONSUME_RECIPE_ARMOUR
        end
      when YE::REGEXP::SYNTH::EVENT
        @synth_event[$1.to_i] = $2.to_i
      when YE::REGEXP::SYNTH::BLOCK
        $1.scan(/\d+/).each { |num|
        if num.to_i > 0
          @synth_block.push(num.to_i)
        end }
      when YE::REGEXP::SYNTH::COST
        @synth_cost = $1.to_i
      when YE::REGEXP::SYNTH::INGRE
        case $1.upcase
        when "I"
          @ingredients[$data_items[$2.to_i]] = 1
        when "W"
          @ingredients[$data_weapons[$2.to_i]] = 1
        when "A"
          @ingredients[$data_armors[$2.to_i]] = 1
        end
      when YE::REGEXP::SYNTH::INGRX
        case $1.upcase
        when "I"
          @ingredients[$data_items[$2.to_i]] = $3.to_i
        when "W"
          @ingredients[$data_weapons[$2.to_i]] = $3.to_i
        when "A"
          @ingredients[$data_armors[$2.to_i]] = $3.to_i
        end
      when YE::REGEXP::SYNTH::REPLAY
        @replay_event = true
      when YE::REGEXP::SYNTH::EXP1
        @synth_exp1 = $1.to_i
      when YE::REGEXP::SYNTH::EXP2
        @synth_exp1 = $1.to_i
        @synth_exp2 = $2.to_i
      when YE::REGEXP::SYNTH::UNBUYABLE
        @synth_unbuyable = true
      end
    }
    self.note.split(/[\r\n]+/).each { |line|
      case line
      when YE::REGEXP::SYNTH::CONSUME
        @synth_consume = true
      when YE::REGEXP::SYNTH::NOTCONSUME
        @synth_consume = false
      end
    }

    if @synth_actor != {} and @ingredients != {}
      @recipe = true
    end
  end

  #--------------------------------------------------------------------------
  # definitions
  #--------------------------------------------------------------------------
  def recipe?
    yanfly_cache_baseitem_ais if @recipe == nil
    return @recipe
  end
  def synth_actor
    yanfly_cache_baseitem_ais if @synth_actor == nil
    return @synth_actor
  end
  def synth_event
    yanfly_cache_baseitem_ais if @synth_event == nil
    return @synth_event
  end
  def synth_block
    yanfly_cache_baseitem_ais if @synth_block == nil
    return @synth_block
  end
  def synth_cost
    yanfly_cache_baseitem_ais if @synth_cost == nil
    return @synth_cost
  end
  def synth_consume?
    yanfly_cache_baseitem_ais if @synth_consume == nil
    return @synth_consume
  end
  def ingredients
    yanfly_cache_baseitem_ais if @ingredients == nil
    return @ingredients
  end
  def replay_event?
    yanfly_cache_baseitem_ais if @replay_event == nil
    return @replay_event
  end
  def synth_exp1
    yanfly_cache_baseitem_ais if @synth_exp1 == nil
    return @synth_exp1
  end
  def synth_exp2
    yanfly_cache_baseitem_ais if @synth_exp2 == nil
    return @synth_exp2
  end
  def synth_unbuyable
    yanfly_cache_baseitem_ais if @synth_unbuyable == nil
    return @synth_unbuyable
  end

end # RPG::BaseItem

#===============================================================================
# Game_Actor
#===============================================================================

class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------
  # Next Exp - The experience needed for the next level.
  #--------------------------------------------------------------------------
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end

  #--------------------------------------------------------------------------
  # learn_recipe
  #--------------------------------------------------------------------------
  def learn_recipe(item)
    if item.is_a?(RPG::Item)
      unless synth_items.include?(item.id)
        synth_items.push(item.id)
        exp = [[item.synth_exp1, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      else
        exp = [[item.synth_exp2, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      end
    elsif item.is_a?(RPG::Weapon)
      unless synth_weapons.include?(item.id)
        synth_weapons.push(item.id)
        exp = [[item.synth_exp1, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      else
        exp = [[item.synth_exp2, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      end
    elsif item.is_a?(RPG::Armor)
      unless synth_armours.include?(item.id)
        synth_armours.push(item.id)
        exp = [[item.synth_exp1, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      else
        exp = [[item.synth_exp2, next_exp - 1].min, 0].max
        gain_exp(exp, false)
      end
    end
  end

  #--------------------------------------------------------------------------
  # synth_events
  #--------------------------------------------------------------------------
  def synth_events
    @synth_events = [] if @synth_events == nil
    return @synth_events
  end

  #--------------------------------------------------------------------------
  # synth_items
  #--------------------------------------------------------------------------
  def synth_items
    @synth_items = [] if @synth_items == nil
    return @synth_items
  end

  #--------------------------------------------------------------------------
  # synth_weapons
  #--------------------------------------------------------------------------
  def synth_weapons
    @synth_weapons = [] if @synth_weapons == nil
    return @synth_weapons
  end

  #--------------------------------------------------------------------------
  # synth_armours
  #--------------------------------------------------------------------------
  def synth_armours
    @synth_armours = [] if @synth_armours == nil
    return @synth_armours
  end

end # Game_Actor

#===============================================================================
# Spriteset_Menu
#===============================================================================

class Spriteset_Menu
  unless method_defined?(:create_viewports)
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    create_viewports
    create_pictures
    update
  end

  def create_viewports
    @viewport1 = Viewport.new(0, 0, 544, 416)
    @viewport2 = Viewport.new(0, 0, 544, 416)
    @viewport3 = Viewport.new(0, 0, 544, 416)
    @viewport2.z = 50
    @viewport3.z = 100
  end

  def create_pictures
    @picture_sprites = []
    for i in 1..20
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
      $game_map.screen.pictures[i]))
    end
  end

  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    dispose_pictures
    dispose_viewports
  end

  def dispose_pictures
    for sprite in @picture_sprites
      sprite.dispose
    end
  end

  def dispose_viewports
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    update_pictures
    update_viewports
  end

  def update_pictures
    for sprite in @picture_sprites
      sprite.update
    end
  end

  def update_viewports
    @viewport1.tone = $game_map.screen.tone
    @viewport1.ox = $game_map.screen.shake
    @viewport2.color = $game_map.screen.flash_color
    @viewport3.color.set(0, 0, 0, 255 - $game_map.screen.brightness)
    @viewport1.update
    @viewport2.update
    @viewport3.update
  end
  end
end # Spriteset_Menu

#===============================================================================
# Scene_Map
#===============================================================================

class Scene_Map < Scene_Base

  #--------------------------------------------------------------------------
  # alias call_shop
  #--------------------------------------------------------------------------
  alias call_shop_ais call_shop unless $@
  def call_shop
    if $game_switches[YE::SYNTH::SYNTH_SWITCH]
      $game_temp.next_scene = nil
      $game_switches[YE::SYNTH::SYNTH_SWITCH] = false
      $scene = Scene_Synthesis.new
    else
      call_shop_ais
    end
  end

end # Scene_Map

#===============================================================================
# Scene_Synthesis
#===============================================================================

class Scene_Synthesis < Scene_Base

  #--------------------------------------------------------------------------
  # start
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @actor_index = 0
    @actor_id = $game_party.members[@actor_index].id
    @interpreter = Game_Interpreter.new
    @common_event = 0
    @spriteset = Spriteset_Menu.new
    @running = false
    @help_window = Window_Help.new
    @gold_window = Window_Gold.new(384, @help_window.height)
    create_command_window
    adjust_window_size
    dy = @help_window.height + @gold_window.height
    dw = Graphics.width - 304
    dh = Graphics.height - dy
    @buy_window = Window_SynthBuy.new(0, dy, 304, dh)
    @buy_window.help_window = @help_window
    @number_window = Window_ShopNumber.new(0, 112)
    @number_window.active = false
    @number_window.visible = false
    @status_window = Window_ShopStatus.new(304, dy)
    @status_window.height = dh
    @status_window.create_contents
    @synth_list = Window_SynthList.new(0, dy, 304, dh)
    @synth_list.help_window = @help_window
    @ingre_list = Window_Ingredients.new(304, dy, dw, dh)
    @synth_number = Window_SynthNumber.new(0, 112)
    @synth_number.visible = false
    @synth_number.active = false
    @message_window = Window_Message.new
    @help_window.set_text("")
    setup_display_item_query if $imported["DisplayItemQuery"]
  end

  #--------------------------------------------------------------------------
  # adjust_window_size
  #--------------------------------------------------------------------------
  def adjust_window_size
    return unless $imported["HelpExtension"]
    @help_window.row_max = KGC::HelpExtension::ROW_MAX
    @command_window.y = @help_window.height
    @gold_window.y = @help_window.height
    dy = @help_window.height + @command_window.height
  end

  #--------------------------------------------------------------------------
  # terminate
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @spriteset.dispose if @spriteset != nil
    @help_window.dispose if @help_window != nil
    @gold_window.dispose if @gold_window != nil
    @buy_window.dispose if @buy_window != nil
    @number_window.dispose if @number_window != nil
    @status_window.dispose if @status_window != nil
    @synth_list.dispose if @synth_list != nil
    @ingre_list.dispose if @ingre_list != nil
    @command_window.dispose if @command_window != nil
    @synth_number.dispose if @synth_number != nil
    @message_window.dispose if @message_window != nil
  end

  #--------------------------------------------------------------------------
  # create_command_window
  #--------------------------------------------------------------------------
  def create_command_window
    carray = []
    carray.push(Vocab::ShopBuy)
    carray.push(YE::SYNTH::SYNTH_TEXT)
    carray.push(Vocab::ShopCancel)
    @command_window = Window_Command.new(384, carray, 3)
    @command_window.y = @help_window.height
  end

  #--------------------------------------------------------------------------
  # setup_display_item_query
  #--------------------------------------------------------------------------
  def setup_display_item_query
    sdx = 0
    sdy = @buy_window.y
    sdw = 272
    sdh = @buy_window.height
    @item_data_window = Window_Item_Data.new(0, sdy, 272, sdh)
    @item_data_window.visible = false
    @item_data_window.active = false
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    update_basic
    update_ingredients_window
    return if @interpreter.running?
    return if $game_message.visible
    if $imported["DisplayItemQuery"] and @item_data_window != nil and
    @item_data_window.active
      update_item_data_window
    elsif @command_window.active
      update_command_window
    elsif @buy_window.active
      @last_index = @buy_window.index + 1
      update_buy_selection
    elsif @synth_list.active
      update_synth_list
    elsif @number_window.active
      update_number_input
    elsif @synth_number.active
      update_synth_number
    end
  end

  #--------------------------------------------------------------------------
  # update_basic
  #--------------------------------------------------------------------------
  def update_basic
    update_menu_background
    update_interpreter
    $game_map.update
    @interpreter.update
    @spriteset.update
    @message_window.update
  end

  #--------------------------------------------------------------------------
  # update_interpreter
  #--------------------------------------------------------------------------
  def update_interpreter
    if !@interpreter.running? and @running
      Graphics.fadeout(YE::SYNTH::FADE_TIME)
      @command_window.visible = true
      @gold_window.visible = true
      @help_window.visible = true
      @synth_list.visible = true
      @ingre_list.visible = true
      @synth_list.update
      Graphics.fadein(YE::SYNTH::FADE_TIME)
      @running = false
    elsif @interpreter.running? and !@running
      Graphics.fadeout(YE::SYNTH::FADE_TIME)
      @command_window.visible = false
      @gold_window.visible = false
      @help_window.visible = false
      @synth_list.visible = false
      @ingre_list.visible = false
      Graphics.fadein(YE::SYNTH::FADE_TIME)
      @running = true
    end
    if @common_event > 0
      @interpreter.setup($data_common_events[@common_event].list)
      @common_event = 0
      return
    end
  end

  #--------------------------------------------------------------------------
  # update_ingredients_window
  #--------------------------------------------------------------------------
  def update_ingredients_window
    return unless @ingre_list.visible
    return if @ingre_list.item == @synth_list.item
    @ingre_list.item = @synth_list.item
    @ingre_list.refresh(@actor_index)
  end

  #--------------------------------------------------------------------------
  # update_item_data_window
  #--------------------------------------------------------------------------
  def update_item_data_window
    @item_data_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @item_data_window.disappear
      @buy_window.active = true
    elsif Input.trigger?(Input::LEFT) or Input.trigger?(Input::UP)
      @item_data_window.previous_page
    elsif Input.trigger?(Input::RIGHT) or Input.trigger?(Input::DOWN)
      @item_data_window.next_page
    elsif Input.trigger?(Input::L)
      @item_data_window.top_page
    elsif Input.trigger?(Input::R)
      @item_data_window.bottom_page
    end
  end

  #--------------------------------------------------------------------------
  # update_command_window
  #--------------------------------------------------------------------------
  def update_command_window
    @command_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      case @command_window.index
      when 0
        Sound.play_decision
        @command_window.active = false
        @buy_window.index = 0 if @buy_window.index < 0
        @buy_window.active = true
        @buy_window.refresh
        @status_window.visible = true
      when 1
        @synth_list.active = true
        @synth_list.visible = true
        @ingre_list.visible = true
        @synth_list.refresh(@actor_index)
        @buy_window.visible = false
        @status_window.visible = false
        @command_window.active = false
      when 2
        $scene = Scene_Map.new
      end
    end
  end

  #--------------------------------------------------------------------------
  # update_buy_selection
  #--------------------------------------------------------------------------
  def update_buy_selection
    if @last_index != @buy_window.index
      @last_index = @buy_window.index
      @status_window.item = @buy_window.item
    end
    @buy_window.update
    if $imported["DisplayItemQuery"] and
    Input.trigger?(YE::MENU::ITEM::ITEM_QUERY_SHOP_BUTTON)
      @item = @buy_window.item
      if @item == nil
        Sound.play_buzzer
      else
        Sound.play_decision
        @item = @buy_window.item
        @item_data_window.appear(@item, @buy_window, 2)
        @buy_window.active = false
      end
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      @command_window.active = true
      @buy_window.active = false
      @status_window.item = nil
      @help_window.set_text("")
      return
    elsif Input.trigger?(Input::C)
      @item = @buy_window.item
      if @item == nil
        Sound.play_buzzer
        return
      end
      number = $game_party.item_number(@item)
      limit = $imported["LimitBreak"] ? @item.number_limit : 99
      if $imported["VariableControlledDiscounts"]
        price = @item.price * $game_variables[YE::EVENT::VARIABLE::PERCENT_BUY]
        price /= YE::EVENT::VARIABLE::PERCENT_DIVISOR
      else
        price = @item.price
      end
      if @item == nil or price > $game_party.gold or number == limit
        Sound.play_buzzer
      else
        Sound.play_decision
        if $imported["LimitBreak"]
          max = (price == 0 ? @item.number_limit : $game_party.gold / price)
          max = [max, @item.number_limit - number].min
        else
          max = price == 0 ? 99 : $game_party.gold / price
          max = [max, 99 - number].min
          end
        @buy_window.active = false
        @buy_window.visible = false
        @number_window.set(@item, max, price)
        @number_window.active = true
        @number_window.visible = true
      end
    end
  end

  #--------------------------------------------------------------------------
  # update_synth_list
  #--------------------------------------------------------------------------
  def update_synth_list
    @synth_list.update
    @help_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @command_window.active = true
      @command_window.visible = true
      @synth_list.active = false
      @synth_list.visible = false
      @ingre_list.visible = false
      @buy_window.visible = true
      @buy_window.refresh
      @status_window.visible = true
      @help_window.set_text("")
    elsif Input.trigger?(Input::C)
      item = @synth_list.item
      unless enabled?(item)
        Sound.play_buzzer
      else
        Sound.play_decision
        synthesize_item(item)
      end
    elsif Input.trigger?(Input::LEFT)
      Sound.play_cursor
      if @actor_index == 0
        @actor_index = $game_party.members.size - 1
      else
        @actor_index -= 1
      end
      @actor_id = $game_party.members[@actor_index].id
      @synth_list.refresh(@actor_index)
      @ingre_list.refresh(@actor_index)
    elsif Input.trigger?(Input::RIGHT)
      Sound.play_cursor
      if @actor_index == $game_party.members.size - 1
        @actor_index = 0
      else
        @actor_index += 1
      end
      @actor_id = $game_party.members[@actor_index].id
      @synth_list.refresh(@actor_index)
      @ingre_list.refresh(@actor_index)
    end
  end

  #--------------------------------------------------------------------------
  # update_number_input
  #--------------------------------------------------------------------------
  def update_number_input
    @number_window.update
    if Input.trigger?(Input::B)
      Sound.play_decision
      @buy_window.active = true
      @buy_window.visible = true
      @buy_window.refresh
      @number_window.active = false
      @number_window.visible = false
    elsif Input.trigger?(Input::C)
      Sound.play_shop
      if $imported["VariableControlledDiscounts"]
        price = @item.price * $game_variables[YE::EVENT::VARIABLE::PERCENT_BUY]
        price /= YE::EVENT::VARIABLE::PERCENT_DIVISOR
      else
        price = @item.price
      end
      $game_party.lose_gold(@number_window.number * price)
      $game_party.gain_item(@item, @number_window.number)
      @gold_window.refresh
      @buy_window.refresh
      @status_window.refresh
      @buy_window.active = true
      @buy_window.visible = true
      @buy_window.refresh
      @number_window.active = false
      @number_window.visible = false
    end
  end

  #--------------------------------------------------------------------------
  # update_synth_number
  #--------------------------------------------------------------------------
  def update_synth_number
    @synth_number.update
    if Input.trigger?(Input::B)
      Sound.play_decision
      @synth_list.active = true
      @synth_list.visible = true
      @synth_number.active = false
      @synth_number.visible = false
    elsif Input.trigger?(Input::C)
      Sound.play_shop
      item = @synth_list.item
      $game_party.lose_gold(@synth_number.number * item.synth_cost)
      if item.synth_actor.include?($game_party.members[@actor_index].id)
        synth = item.synth_actor[$game_party.members[@actor_index].id]
      else
        synth = item.synth_actor[0]
      end
      $game_party.gain_item(synth, @synth_number.number)
      consume_ingredients(item, @synth_number.number)
      @gold_window.refresh
      $game_actors[@actor_id].learn_recipe(item)
      run_common_event(item)
      @synth_list.refresh(@actor_index)
      @ingre_list.refresh(@actor_index)
      @synth_list.active = true
      @synth_list.visible = true
      @synth_number.active = false
      @synth_number.visible = false
    end
  end

  #--------------------------------------------------------------------------
  # enabled?
  #--------------------------------------------------------------------------
  def enabled?(item)
    return false if item == nil
    return false if @actor_index == -1
    return false if item.synth_block.include?(@actor_id)
    return false unless (item.synth_actor.include?(@actor_id) or
    item.synth_actor.include?(0))
    for ingredient in item.ingredients
      return false if $game_party.item_number(ingredient[0]) < ingredient[1]
    end
    return false unless $game_party.gold >= item.synth_cost
    return true
  end

  #--------------------------------------------------------------------------
  # synthesize_item
  #--------------------------------------------------------------------------
  def synthesize_item(item)
    if item.synth_cost > 0
      max = $game_party.gold / item.synth_cost
    else
      max = $game_party.gold
    end
    if item.synth_consume?
      max = [max, $game_party.item_number(item)].min
    end
    for ingredient in item.ingredients
      next if ingredient[1] == 0
      n = $game_party.item_number(ingredient[0]) / ingredient[1]
      max = [max, n].min
    end
    number = $game_party.item_number(item)
    limit = ($imported["LimitBreak"] ? item.number_limit : 99)
    max = [max, limit - number].min
    synth = synth_number_item(item)
    @synth_number.set(synth, max, item.synth_cost, item)
    @synth_number.visible = true
    @synth_number.active = true
    @synth_list.visible = false
    @synth_list.active = false
  end

  #--------------------------------------------------------------------------
  # consume_ingredients
  #--------------------------------------------------------------------------
  def consume_ingredients(item, number)
    if item.synth_consume?
      $game_party.lose_item(item, number)
    end
    for ingredient in item.ingredients
      $game_party.lose_item(ingredient[0], number * ingredient[1])
    end
  end

  #--------------------------------------------------------------------------
  # synth_number_item
  #--------------------------------------------------------------------------
  def synth_number_item(item)
    if item.is_a?(RPG::Item)
      if $game_party.members[@actor_index].synth_items.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          item = item.synth_actor[$game_party.members[@actor_index].id]
        elsif item.synth_actor.include?(0)
          item = item.synth_actor[0]
        end
      end
    elsif item.is_a?(RPG::Weapon)
      if $game_party.members[@actor_index].synth_weapons.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          item = item.synth_actor[$game_party.members[@actor_index].id]
        elsif item.synth_actor.include?(0)
          item = item.synth_actor[0]
        end
      end
    elsif item.is_a?(RPG::Armor)
      if $game_party.members[@actor_index].synth_armours.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          item = item.synth_actor[$game_party.members[@actor_index].id]
        elsif item.synth_actor.include?(0)
          item = item.synth_actor[0]
        end
      end
    end
    return item
  end

  #--------------------------------------------------------------------------
  # run_common_event
  #--------------------------------------------------------------------------
  def run_common_event(item)
    event = nil
    actor = $game_party.members[@actor_index]
    if item.synth_event.include?(actor.id)
      @synth_list.update
      event = item.synth_event[actor.id]
    elsif item.synth_event.include?(0)
      @synth_list.update
      event = item.synth_event[0]
    end
    return if event == nil
    if !actor.synth_events.include?(event) or item.replay_event?
      actor.synth_events.push(event) unless actor.synth_events.include?(event)
      if YE::SYNTH::EVENT_IN_SHOP
        @common_event = event
      else
        $game_temp.common_event_id = event
        $scene = Scene_Map.new
      end
    end
  end

end # Scene_Synthesis

#==============================================================================
# Window_SynthList
#==============================================================================

class Window_SynthList < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h)
    super(x, y, w, h)
    self.visible = false
    self.active = false
    self.index = 0
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(actor_index = -1)
    @data = []
    for goods_item in $game_temp.shop_goods
      case goods_item[0]
      when 0
        item = $data_items[goods_item[1]]
      when 1
        item = $data_weapons[goods_item[1]]
      when 2
        item = $data_armors[goods_item[1]]
      end
      next if item == nil
      next unless item.recipe?
      next unless $game_party.has_item?(item)
      @data.push(item)
    end
    @item_max = @data.size
    create_contents
    @actor_index = actor_index
    @actor_id = $game_party.members[@actor_index].id
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    enable = enabled?(item)
    if @actor_index >= 0 and item.synth_actor.include?(@actor_id)
      if item.is_a?(RPG::Item)
        if $game_actors[@actor_id].synth_items.include?(item.id)
          item = item.synth_actor[@actor_id]
        end
      elsif item.is_a?(RPG::Weapon)
        if $game_actors[@actor_id].synth_weapons.include?(item.id)
          item = item.synth_actor[@actor_id]
        end
      elsif item.is_a?(RPG::Armor)
        if $game_actors[@actor_id].synth_armours.include?(item.id)
          item = item.synth_actor[@actor_id]
        end
      end
    elsif @actor_index >= 0 and item.synth_actor.include?(0)
      if item.is_a?(RPG::Item)
        if $game_actors[@actor_id].synth_items.include?(item.id)
          item = item.synth_actor[0]
        end
      elsif item.is_a?(RPG::Weapon)
        if $game_actors[@actor_id].synth_weapons.include?(item.id)
          item = item.synth_actor[0]
        end
      elsif item.is_a?(RPG::Armor)
        if $game_actors[@actor_id].synth_armours.include?(item.id)
          item = item.synth_actor[0]
        end
      end
    end
    draw_item_name(item, rect.x, rect.y, enable)
  end

  #--------------------------------------------------------------------------
  # enabled?
  #--------------------------------------------------------------------------
  def enabled?(item)
    return false if item == nil
    return false if @actor_index == -1
    return false if item.synth_block.include?(@actor_id)
    return false unless (item.synth_actor.include?(@actor_id) or
    item.synth_actor.include?(0))
    for ingredient in item.ingredients
      return false if $game_party.item_number(ingredient[0]) < ingredient[1]
    end
    return false unless $game_party.gold >= item.synth_cost
    return true
  end

  #--------------------------------------------------------------------------
  # return item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end

  #--------------------------------------------------------------------------
  # update_help
  #--------------------------------------------------------------------------
  def update_help
    if item == nil
      text = ""
    else
      text = item.description
    end
    if item.is_a?(RPG::Item)
      if $game_party.members[@actor_index].synth_items.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          text =
          item.synth_actor[$game_party.members[@actor_index].id].description
        elsif item.synth_actor.include?(0)
          text = item.synth_actor[0].description
        end
      end
    elsif item.is_a?(RPG::Weapon)
      if $game_party.members[@actor_index].synth_weapons.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          text =
          item.synth_actor[$game_party.members[@actor_index].id].description
        elsif item.synth_actor.include?(0)
          text = item.synth_actor[0].description
        end
      end
    elsif item.is_a?(RPG::Armor)
      if $game_party.members[@actor_index].synth_armours.include?(item.id)
        if item.synth_actor.include?($game_party.members[@actor_index].id)
          text =
          item.synth_actor[$game_party.members[@actor_index].id].description
        elsif item.synth_actor.include?(0)
          text = item.synth_actor[0].description
        end
      end
    end
    @help_window.set_text(text)
  end

end # Window_SynthList

#==============================================================================
# Window_Ingredients
#==============================================================================

class Window_Ingredients < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h)
    super(x, y, w, h)
    self.visible = false
    @item = nil
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(actor_index = -1)
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = 255
    self.contents.font.size = Font.default_size
    @actor_index = actor_index
    draw_actor
    draw_ingredients
  end

  #--------------------------------------------------------------------------
  # return item
  #--------------------------------------------------------------------------
  def item
    return @item
  end

  #--------------------------------------------------------------------------
  # item=
  #--------------------------------------------------------------------------
  def item=(item)
    if @item != item
      @item = item
      refresh
    end
  end

  #--------------------------------------------------------------------------
  # draw_actor
  #--------------------------------------------------------------------------
  def draw_actor
    return if @actor_index < 0
    sw = self.width - 32
    actor = $game_party.members[@actor_index]
    draw_actor_graphic(actor, 24, WLH*2)
    self.contents.draw_text(48, 0, sw-48, WLH, actor.name)
    self.contents.font.size = YE::SYNTH::SYNTH_FSIZE
    total = actor.synth_items.size + actor.synth_weapons.size +
    actor.synth_armours.size
    text = sprintf(YE::SYNTH::SYNTH_TOTAL, total)
    xoffset = YE::SYNTH::SYNTH_OFFSET
    self.contents.draw_text(48, 24, sw-48, WLH, text)
  end

  #--------------------------------------------------------------------------
  # draw_ingredients
  #--------------------------------------------------------------------------
  def draw_ingredients
    return if @item == nil
    self.contents.font.size = Font.default_size
    sw = self.width - 32
    dy = 48
    if incompatible? or
    @item.synth_block.include?($game_party.members[@actor_index].id)
      self.contents.font.color = text_color(YE::SYNTH::SYNTH_INCOLR)
      self.contents.draw_text(0, dy, sw, WLH, YE::SYNTH::SYNTH_INCOMP, 1)
      return
    else
      self.contents.font.color = system_color
      self.contents.draw_text(0, dy, sw, WLH, @item.name, 1)
    end
    dy += 24
    self.contents.font.color = normal_color
    self.contents.font.size = YE::SYNTH::SYNTH_FSIZE
    if item.synth_cost > 0
      enabled = ($game_party.gold >= item.synth_cost) ? true : false
      draw_icon(YE::SYNTH::SYNTH_C_ICON, 0, dy, enabled)
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(24, dy, sw-24, WLH, YE::SYNTH::SYNTH_COST)
      text = sprintf(YE::SYNTH::SYNTH_T_COST, item.synth_cost, Vocab.gold)
      self.contents.draw_text(24, dy, sw-24, WLH, text, 2)
      dy += 24
    end
    if item.synth_consume?
      draw_item_name(item, 0, dy)
      amount = $game_party.item_number(item)
      text = sprintf(YE::SYNTH::SYNTH_AMT, 1, amount)
      self.contents.draw_text(0, dy, sw, WLH, text, 2)
      dy += 24
    end
    item_list = @item.ingredients.sort { |a,b| a[0].name <=> b[0].name }
    for key in item_list
      amount = $game_party.item_number(key[0])
      if amount >= key[1]
        self.contents.font.color.alpha = 255
        enabled = true
      else
        self.contents.font.color.alpha = 128
        enabled = false
      end
      draw_item_name(key[0], 0, dy, enabled)
      text = sprintf(YE::SYNTH::SYNTH_AMT, key[1], amount)
      self.contents.draw_text(0, dy, sw, WLH, text, 2) unless key[1] == 0 and
      YE::SYNTH::SYNTH_HIDE_0
      dy += 24
    end
  end

  #--------------------------------------------------------------------------
  # incompatible?
  #--------------------------------------------------------------------------
  def incompatible?
    actor = $game_party.members[@actor_index]
    if item.synth_actor.include?(actor.id)
      return false
    elsif item.synth_actor.include?(0)
      return false
    end
    return true
  end

end # Window_Ingredients

#==============================================================================
# Window_SynthBuy
#==============================================================================

class Window_SynthBuy < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h)
    super(x, y, w, h)
    @shop_goods = $game_temp.shop_goods
    refresh
    self.active = false
    self.index = -1
  end

  #--------------------------------------------------------------------------
  # return item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for goods_item in @shop_goods
      case goods_item[0]
      when 0
        item = $data_items[goods_item[1]]
        next if item == nil
        next unless item.recipe?
        next if item.synth_unbuyable
        for i in 1..$data_actors.size
          actor = $game_actors[i]
          next if actor == nil
          if actor.synth_items.include?(item.id)
            if item.synth_actor.include?(actor.id)
              @data.push(item.synth_actor[actor.id]) unless @data.include?(item)
            elsif item.synth_actor.include?(0)
              @data.push(item.synth_actor[0]) unless @data.include?(item)
            end
          end
        end
      when 1
        item = $data_weapons[goods_item[1]]
        next if item == nil
        next unless item.recipe?
        next if item.synth_unbuyable
        for i in 1..$data_actors.size
          actor = $game_actors[i]
          next if actor == nil
          if actor.synth_weapons.include?(item.id)
            if item.synth_actor.include?(actor.id)
              @data.push(item.synth_actor[actor.id]) unless @data.include?(item)
            elsif item.synth_actor.include?(0)
              @data.push(item.synth_actor[0]) unless @data.include?(item)
            end
          end
        end
      when 2
        item = $data_armors[goods_item[1]]
        next if item == nil
        next unless item.recipe?
        next if item.synth_unbuyable
        for i in 1..$data_actors.size
          actor = $game_actors[i]
          next if actor == nil
          if actor.synth_armours.include?(item.id)
            if item.synth_actor.include?(actor.id)
              @data.push(item.synth_actor[actor.id]) unless @data.include?(item)
            elsif item.synth_actor.include?(0)
              @data.push(item.synth_actor[0]) unless @data.include?(item)
            end
          end
        end
      end
    end
    sort_list
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    number = $game_party.item_number(item)
    if $imported["VariableControlledDiscounts"]
      price = item.price * $game_variables[YE::EVENT::VARIABLE::PERCENT_BUY]
      price /= YE::EVENT::VARIABLE::PERCENT_DIVISOR
    else
      price = item.price
    end
    if $imported["LimitBreak"]
      max = item.number_limit
    else
      max = 99
    end
    if $imported["DisplayItemQuery"]
      if item.is_a?(RPG::Item)
        $game_party.purchased_items[item.id] = [] if
          $game_party.purchased_items[item.id] == nil
        $game_party.purchased_items[item.id].push($game_map.map_id) unless
          $game_party.purchased_items[item.id].include?($game_map.map_id)
      elsif item.is_a?(RPG::Weapon)
        $game_party.purchased_weapons[item.id] = [] if
          $game_party.purchased_weapons[item.id] == nil
        $game_party.purchased_weapons[item.id].push($game_map.map_id) unless
          $game_party.purchased_weapons[item.id].include?($game_map.map_id)
      elsif item.is_a?(RPG::Armor)
        $game_party.purchased_armours[item.id] = [] if
          $game_party.purchased_armours[item.id] == nil
        $game_party.purchased_armours[item.id].push($game_map.map_id) unless
          $game_party.purchased_armours[item.id].include?($game_map.map_id)
      end
    end
    enable = (price <= $game_party.gold and number < max)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    draw_item_name(item, rect.x, rect.y, enable)
    rect.width -= 4
    self.contents.draw_text(rect, price, 2)
  end

  #--------------------------------------------------------------------------
  # sort_list
  #--------------------------------------------------------------------------
  def sort_list
    dummy_items = []; dummy_weapons = []; dummy_armours = []
    for item in @data
      next unless item.is_a?(RPG::Item)
      next if item.synth_unbuyable
      dummy_items.push(item)
    end
    dummy_items = dummy_items.sort{ |a,b| a.id <=> b.id }
    for item in @data
      next unless item.is_a?(RPG::Weapon)
      next if item.synth_unbuyable
      dummy_weapons.push(item)
    end
    dummy_weapons = dummy_weapons.sort{ |c,d| c.id <=> d.id }
    for item in @data
      next unless item.is_a?(RPG::Armor)
      next if item.synth_unbuyable
      dummy_armours.push(item)
    end
    dummy_armours = dummy_armours.sort{ |e,f| e.id <=> f.id }
    @data = dummy_items.uniq
    @data += dummy_weapons.uniq
    @data += dummy_armours.uniq
  end

  #--------------------------------------------------------------------------
  # update_help
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(item == nil ? "" : item.description)
  end

end #Window_SynthBuy

#==============================================================================
# Window_SynthNumber
#==============================================================================

class Window_SynthNumber < Window_ShopNumber

  #--------------------------------------------------------------------------
  # set
  #--------------------------------------------------------------------------
  def set(item, max, price, real)
    @real = real
    super(item, max, price)
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    dy = 0
    sw = self.width - 32
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(0, dy, sw, WLH, YE::SYNTH::SYNTH_OUTCOM, 1)
    dy += 24
    self.contents.font.color = normal_color
    if @item == @real
      draw_icon(YE::SYNTH::SYNTH_UNICON, 0, dy)
      text = YE::SYNTH::SYNTH_UNMASK
      self.contents.draw_text(24, dy, 172, WLH, text)
    else
      draw_item_name(@item, 0, dy)
    end
    self.contents.draw_text(212, dy, 20, WLH, "×")
    self.contents.draw_text(218, dy, 50, WLH, @number, 2)
    self.cursor_rect.set(207, dy, 64, WLH)
    dy += 24
    self.contents.font.color = system_color
    self.contents.draw_text(0, dy, sw, WLH, YE::SYNTH::SYNTH_INGRED, 1)
    self.contents.font.color = normal_color
    if @price != 0
      dy += 24
      draw_icon(YE::SYNTH::SYNTH_C_ICON, 0, dy)
      self.contents.draw_text(24, dy, 172, WLH, YE::SYNTH::SYNTH_COST)
      draw_currency_value(@price * @number, 4, dy, 264)
    end
    if @real.synth_consume?
      dy += 24
      draw_item_name(@real, 0, dy)
      self.contents.draw_text(212, dy, 20, WLH, "×")
      self.contents.draw_text(218, dy, 50, WLH, @number, 2)
    end
    ingredients = @real.ingredients.sort { |a,b| a[0].name <=> b[0].name }
    for ingredient in ingredients
      next if ingredient[0] == nil
      dy += 24
      draw_item_name(ingredient[0], 0, dy)
      unless (@number * ingredient[1] == 0) and YE::SYNTH::SYNTH_HIDE_0
        self.contents.draw_text(212, dy, 20, WLH, "×")
        self.contents.draw_text(218, dy, 50, WLH, @number * ingredient[1], 2)
      end
    end
  end

end # Window_SynthNumber

#===============================================================================
#
# END OF FILE
#
#===============================================================================