DSI Equip Upgrade System

#==============================================================================
# > DSI Equip Upgrade System
# Last Updated: 28/5/2021
# Author: dsiver144
# --------------------------------------------------------------------------
# > Item / Weapon / Armor Notetags:
# --------------------------------------------------------------------------
# To make an item is a free uprade: <free upgrade>
# - Setup upgradeable item/weapon/armor, use these notes:
# For example.
# <upgradeable>
# target: w63
# cost: 2000G, w1x1, a1x1, i18x1
# chance: 60%
# </upgradeable>
# --------------------------------------------------------------------------
# Script call: SceneManager.call(Scene_UpgradeOptions)
# Use that to open upgrade scene.
#==============================================================================
module DSIVER144
  module EQUIP_UPGRADE
    GOLD_ITEM = 23 # An item for display currency in the requirement list.
    # Set below variable to a picture filename if you want to have a background
    OPTION_SCENE_BG = nil # Ex: OPTION_SCENE_BG = "Background"

    SUCCESS_ME = RPG::ME.new("Item", 70, 100)
    FAIL_ME    = RPG::ME.new("Gag", 70, 100)
  end
end

#==============================================================================
# ■ DataManager
#==============================================================================

module DataManager
  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  class <<self;
    alias_method(:dsi_load_database_eus, :load_database)
  end
  def self.load_database
    dsi_load_database_eus
    load_weapon_notetags_eus
  end
  #--------------------------------------------------------------------------
  # new method: load_weapon_notetags_eus
  #--------------------------------------------------------------------------
  def self.load_weapon_notetags_eus
    groups = [$data_weapons, $data_armors, $data_items]
    groups.each do |data|
      data.each do |item|
        next unless item
        item.load_custom_notetag
      end
    end
  end

end # DataManager

class RPG::BaseItem
  attr_accessor :upgrade_info
  attr_accessor :free_upgrade
  #--------------------------------------------------------------------------
  # new method: load_custom_notetag
  #--------------------------------------------------------------------------
  def load_custom_notetag
    read_note = false
    self.note.split(/[\r\n]+/).each do |line|
      if line =~ /<free upgrade>/i
        @free_upgrade = true
      end
      if line =~ /<upgradeable>/i
        @upgrade_info = {}
        read_note = true
        next
      end
      if line =~ /<\/upgradeable>/i
        read_note = false
        next
      end
      if read_note
        if line =~ /target:\s*(\w)(\d+)/i
          @upgrade_info[:target] = {}
          @upgrade_info[:target][:etype] = $1
          @upgrade_info[:target][:id] = $2.to_i
        end
        if line =~ /cost:\s*(.+)/i
          result = []
          items = $1.split(",")
          items.each do |str|
            if str =~ /(\d+)G/i
              data = []
              data << "$data_items[#{DSIVER144::EQUIP_UPGRADE::GOLD_ITEM}]"#DSIVER144::EQUIP_UPGRADE::GOLD_ICON
              data << true
              data << $1.to_i
              result << data
            end
            if str =~ /(w|i|a)(\d+)x(\d+)/i
              case $1
              when "w"
                data = []
                data << "$data_weapons[#{$2.to_i}]"
                data << nil
                data << $3.to_i
                result << data
              when "a"
                data = []
                data << "$data_armors[#{$2.to_i}]"
                data << nil
                data << $3.to_i
                result << data
              when "i"
                data = []
                data << "$data_items[#{$2.to_i}]"
                data << nil
                data << $3.to_i
                result << data
              end
            end
          end
          @upgrade_info[:cost] = result
        end
        if line =~ /chance:\s*(\d+)%?/i
          @upgrade_info[:chance] = $1.to_i
        end
      end
    end
  end
end

class Scene_UpgradeOptions < Scene_MenuBase
  #--------------------------------------------------------------------------
  # new method: start
  #--------------------------------------------------------------------------
  def start
    super
    @upgrade_type = :normal
    @sprite_bg = Sprite.new
    if DSIVER144::EQUIP_UPGRADE::OPTION_SCENE_BG
      @sprite_bg.bitmap = Cache.picture(DSIVER144::EQUIP_UPGRADE::OPTION_SCENE_BG)
    end
    @option_window = Window_UpgradeOptions.new(0, 0)
    @option_window.x = (Graphics.width - @option_window.width) / 2
    @option_window.y = (Graphics.height - @option_window.height) / 2
    @option_window.set_handler(:upgrade, method(:on_normal_upgrade))
    @option_window.set_handler(:free_upgrade, method(:on_free_upgrade))
    @option_window.set_handler(:cancel, method(:return_scene))

    @title_window = Window_Base.new(0, 0, @option_window.width + 80, @option_window.fitting_height(1))
    @title_window.x = (Graphics.width - @title_window.width) / 2
    @title_window.y = 12
    @title_window.draw_text(0, 0, @title_window.contents_width, @title_window.line_height, "UPGRADE SYSTEM", 1)

    @list_window_width = Graphics.width - 24

    @item_list = Window_UpgradeableItemList.new(0, 0, @list_window_width, @title_window.fitting_height(9))
    @item_list.category = :weapon

    @item_category = Window_UpgradeableItemCategory.new
    @item_category.width = @item_list.width
    @item_category.create_contents
    @item_category.refresh

    @item_category.x = (Graphics.width - @item_category.width) / 2
    @item_category.y = @title_window.y + @title_window.height + 12

    @item_list.x = (Graphics.width - @item_list.width) / 2
    @item_list.y = @item_category.y + @item_category.height + 12

    @item_category.item_window = @item_list
    @item_category.set_handler(:ok, method(:on_category_ok))
    @item_category.set_handler(:cancel, method(:on_category_cancel))

    @item_list.set_handler(:ok, method(:on_list_ok))
    @item_list.set_handler(:cancel, method(:on_list_cancel))

    @item_category.deactivate
    @item_category.close
    @item_category.openness = 0
    @item_list.close
    @item_list.openness = 0

    @upgrade_item_list = Window_UpgradeInfoList.new(0, 0, @item_list.width, @item_list.fitting_height(1))
    @upgrade_item_list.x = @item_list.x
    @upgrade_item_list.y = @item_list.y
    @upgrade_item_list.deactivate
    @upgrade_item_list.hide
    @upgrade_item_list.opacity = 0
    @upgrade_item_list.back_opacity = 0
    @upgrade_item_list.set_handler(:ok, method(:on_upgrade_list_ok))
    @upgrade_item_list.set_handler(:cancel, method(:on_upgrade_list_cancel))

    @help_window = Window_Help.new(2)
    @help_window.width = @upgrade_item_list.width
    @help_window.create_contents

    @upgrade_item_list.help_window = @help_window
    @help_window.close
    @help_window.openness = 0

    @upgrade_require_list = Window_UpgradeRequireItemList.new(0, 0, @item_list.width, @item_list.height - @upgrade_item_list.height)
    @upgrade_require_list.hide
    @upgrade_require_list.opacity = 0
    @upgrade_require_list.back_opacity = 0

    @result_window = Window_UpgradeResult.new(0, 0, @upgrade_require_list.width - 30, @upgrade_require_list.fitting_height(2))
    @result_window.x = (Graphics.width - @result_window.width) / 2
    @result_window.y = (Graphics.height - @result_window.height) / 2
    @result_window.close
    @result_window.openness = 0

    @free_upgrade_list = Window_FreeUpgradeItemList.new(0, 0, 300, @upgrade_require_list.fitting_height(6))
    @free_upgrade_list.x = (Graphics.width - @free_upgrade_list.width) / 2
    @free_upgrade_list.y = (Graphics.height - @free_upgrade_list.height) / 2 + 40
    @free_upgrade_list.close
    @free_upgrade_list.openness = 0
    @free_upgrade_list.set_handler(:ok, method(:on_select_free_upgrade_item))
    @free_upgrade_list.set_handler(:cancel, method(:select_free_upgrade_cancel))

    @original_y = @item_list.y

  end
  #--------------------------------------------------------------------------
  # new method: open_upgrade_windows
  #--------------------------------------------------------------------------
  def open_upgrade_windows(type = :normal)
    @last_category_index = nil
    @free_upgrade_item = nil
    @upgrade_type = type
    @option_window.close
    @item_category.open
    @item_list.unselect
    @item_list.open
    if type == :normal
      @item_category.activate
    else
      @item_category.unselect
      @free_upgrade_list.refresh
      @free_upgrade_list.open
      @free_upgrade_list.activate
      @free_upgrade_list.select(0)
    end
  end
  #--------------------------------------------------------------------------
  # new method: on_select_free_upgrade_item
  #--------------------------------------------------------------------------
  def on_select_free_upgrade_item
    @free_upgrade_item = @free_upgrade_list.item
    @free_upgrade_list.close
    @item_category.activate
    @item_category.select(@last_category_index ? @last_category_index : 0)
  end
  #--------------------------------------------------------------------------
  # new method: select_free_upgrade_cancel
  #--------------------------------------------------------------------------
  def select_free_upgrade_cancel
    @free_upgrade_list.close
    on_category_cancel
  end
  #--------------------------------------------------------------------------
  # new method: on_normal_upgrade
  #--------------------------------------------------------------------------
  def on_normal_upgrade
    open_upgrade_windows
  end
  #--------------------------------------------------------------------------
  # new method: on_free_upgrade
  #--------------------------------------------------------------------------
  def on_free_upgrade
    open_upgrade_windows(:free)
  end
  #--------------------------------------------------------------------------
  # new method: on_category_ok
  #--------------------------------------------------------------------------
  def on_category_ok
    @item_list.activate
    @item_list.select_last
  end
  #--------------------------------------------------------------------------
  # new method: on_category_cancel
  #--------------------------------------------------------------------------
  def on_category_cancel
    @item_category.close
    @item_list.close
    @option_window.refresh
    @option_window.open
    @option_window.activate
  end
  #--------------------------------------------------------------------------
  # new method: free_upgrade_item
  #--------------------------------------------------------------------------
  def free_upgrade_item
    return @free_upgrade_item
  end
  #--------------------------------------------------------------------------
  # new method: on_list_ok
  #--------------------------------------------------------------------------
  def on_list_ok
    upgrade_item = @item_list.item
    @item_category.close
    tween(@item_list, [[:y, @item_category.y]], 15) do
      @help_window.x = @item_list.x
      @help_window.y = @item_list.y + @item_list.height + 12
      @help_window.open
      @upgrade_item_list.activate
    end
    @last_select = @item_list.index
    @upgrade_item_list.set_item(upgrade_item)
    @upgrade_require_list.set_item(upgrade_item)
    @item_list.unselect
    @item_list.contents.clear
    @upgrade_item_list.show
    @upgrade_item_list.select(1)
    @upgrade_require_list.show
    @item_list.show_info(upgrade_item)
  end
  #--------------------------------------------------------------------------
  # new method: on_list_cancel
  #--------------------------------------------------------------------------
  def on_list_cancel
    @item_list.unselect
    @item_category.activate
  end
  #--------------------------------------------------------------------------
  # new method: on_upgrade_list_ok
  #--------------------------------------------------------------------------
  def on_upgrade_list_ok
    if @upgrade_require_list.can_be_upgraded?
      Sound.play_ok
      @result_window.open
      @result_window.set_item(*@upgrade_item_list.upgrade_item(@upgrade_type)) do
        if @upgrade_type == :free && $game_party.item_number(free_upgrade_item) == 0
          @last_category_index = @item_category.index
          if @option_window.has_free_upgrade?
            on_upgrade_list_cancel(false)
            @item_list.unselect
            @free_upgrade_list.refresh
            @free_upgrade_list.open
            @free_upgrade_list.activate
          else
            on_upgrade_list_cancel(false) do
              on_category_cancel
            end
          end

        else
          on_upgrade_list_cancel
        end
      end
    else
      Sound.play_buzzer
      @upgrade_item_list.activate
    end
  end
  #--------------------------------------------------------------------------
  # new method: on_upgrade_list_cancel
  #--------------------------------------------------------------------------
  def on_upgrade_list_cancel(activate_item_list = true, &callback)
    @help_window.close
    tween(@item_list, [[:y, @original_y]], 15) do
      @item_category.open
      @item_list.activate if activate_item_list
      callback.call if callback
    end
    @upgrade_require_list.hide
    @upgrade_item_list.hide
    @item_list.refresh
    @item_list.select(@last_select)
  end
  #--------------------------------------------------------------------------
  # new method: update
  #--------------------------------------------------------------------------
  def update
    super
    @upgrade_item_list.x = @item_list.x
    @upgrade_item_list.y = @item_list.y
    @upgrade_require_list.x = @item_list.x
    @upgrade_require_list.y = @item_list.y + @item_list.height - @upgrade_require_list.height
  end
  #--------------------------------------------------------------------------
  # new method: terminate
  #--------------------------------------------------------------------------
  def terminate
    super
    @sprite_bg.dispose
  end

end

class Window_UpgradeOptions < Window_Command
  #--------------------------------------------------------------------------
  # * Has Free Upgrade?
  #--------------------------------------------------------------------------
  def has_free_upgrade?
    $game_party.items.any? {|item| item.free_upgrade }
  end
  #--------------------------------------------------------------------------
  # * Alignment
  #--------------------------------------------------------------------------
  def alignment
    1
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    return 250
  end

  def make_command_list
    add_command("Upgrade", :upgrade, true)
    add_command("Free Upgrade", :free_upgrade, has_free_upgrade?)
    add_command("Exit", :cancel, true)
  end

end

class Window_UpgradeableItemCategory < Window_ItemCategory
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    Graphics.width
  end
  #--------------------------------------------------------------------------
  # * Get Digit Count
  #--------------------------------------------------------------------------
  def col_max
    return 3
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    @item_window.category = current_symbol if @item_window
  end
  #--------------------------------------------------------------------------
  # * Create Command List
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(Vocab::item,     :item)
    add_command(Vocab::weapon,   :weapon)
    add_command(Vocab::armor,    :armor)
  end
end

class Window_UpgradeableItemList < Window_ItemList
  #--------------------------------------------------------------------------
  # * upgradeable?
  #--------------------------------------------------------------------------
  def upgradeable?(item)
    return !!item.upgrade_info
  end
  #--------------------------------------------------------------------------
  # * Include in Item List?
  #--------------------------------------------------------------------------
  def include?(item)
    return super && upgradeable?(item)
  end
  #--------------------------------------------------------------------------
  # * Display in Enabled State?
  #--------------------------------------------------------------------------
  def enable?(item)
    !!item
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def make_item_list
    @data = $game_party.all_items.select {|item| include?(item) }
    @data.push(nil) if include?(nil)
  end
  #--------------------------------------------------------------------------
  # * Show Info
  #--------------------------------------------------------------------------
  def show_info(item)
    dx = 0
    dy = 0
    cw = contents_width
    ch = contents_height
    lh = line_height
    dy = line_height
    draw_icon(726, (cw - 24) / 2, 0)
    draw_text(dx, dy, cw, lh, "- Requirements -", 1)
    dy += line_height
  end

end

class Window_UpgradeInfoList < Window_ItemList
  #--------------------------------------------------------------------------
  # * Processing When OK Button Is Pressed
  #--------------------------------------------------------------------------
  def process_ok
    if current_item_enabled?
      Input.update
      deactivate
      call_ok_handler
    else
      Sound.play_buzzer
    end
  end
  #--------------------------------------------------------------------------
  # * Display in Enabled State?
  #--------------------------------------------------------------------------
  def enable?(item)
    true
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def set_item(item)
    @upgrade_item = item
    refresh
  end
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def draw_item_number(rect, item)
    # Do nothing
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def upgrade_item(upgrade_type = :normal)
    target = @data[1]
    chance = @upgrade_item.upgrade_info[:chance]
    cost = @upgrade_item.upgrade_info[:cost]
    if upgrade_type == :normal
      cost.each do |data|
        item = eval(data[0])
        if data[1]
          $game_party.lose_gold(data[2])
        else
          $game_party.lose_item(item, data[2])
        end
      end
    else
      free_upgrade_item = SceneManager.scene.free_upgrade_item
      $game_party.lose_item(free_upgrade_item, 1)
    end
    result = rand(100) <= chance
    if result
      $game_party.gain_item(target, 1)
      $game_party.lose_item(@data[0], 1)
    else
      target = @data[0]
    end
    p [result, @data]
    return [result, target]
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def make_item_list
    return unless @upgrade_item
    target_item = nil
    id = @upgrade_item.upgrade_info[:target][:id]
    case @upgrade_item.upgrade_info[:target][:etype]
    when "i"
      target_item = $data_items[id]
    when "w"
      target_item = $data_weapons[id]
    when "i"
      target_item = $data_armors[id]
    end
    @data = [@upgrade_item, target_item]
  end

end

class Window_UpgradeRequireItemList < Window_ItemList
  #--------------------------------------------------------------------------
  # * Display in Enabled State?
  #--------------------------------------------------------------------------
  def enable?(item)
    true
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def set_item(item)
    @upgrade_item = item
    refresh
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index)
    @current_draw_index = index
    brect = item_rect(index).clone
    brect.y += 1
    brect.height -= 2
    contents.fill_rect(brect, Color.new(0,0,0,100))
    super(index)
  end
  #--------------------------------------------------------------------------
  # * Draw Number of Items
  #--------------------------------------------------------------------------
  def draw_item_number(rect, item)
    index = @current_draw_index
    return unless @custom_data[index]
    left_num = 0
    if @custom_data[index][0]
      left_num = $game_party.gold
    else
      left_num = $game_party.item_number(item)
    end
    right_num = @custom_data[index][1]
    if left_num >= right_num
      change_color(text_color(3))
      @can_upgrade_count += 1
    else
      change_color(text_color(10))
    end
    draw_text(rect, sprintf("%2d/%2d", left_num, right_num), 2)
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def spacing
    return 4
  end
  #--------------------------------------------------------------------------
  # * Can be upgraded?
  #--------------------------------------------------------------------------
  def can_be_upgraded?
    @can_upgrade_count >= @custom_data.size
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def make_item_list
    return unless @upgrade_item
    @can_upgrade_count = 0
    target_item = nil
    cost = @upgrade_item.upgrade_info[:cost]
    @custom_data = []
    @data = []
    free_upgrade_item = SceneManager.scene.free_upgrade_item
    if free_upgrade_item
      @data << free_upgrade_item
      @custom_data << [false, 1]
    else
      cost.each do |data|
        item = eval(data[0])
        @data << item
        @custom_data << [data[1], data[2]]
      end
    end
  end

end

class Window_UpgradeResult < Window_ItemList
  #--------------------------------------------------------------------------
  # * Enable
  #--------------------------------------------------------------------------
  def enable?(item)
    true
  end
  #--------------------------------------------------------------------------
  # * Set Item
  #--------------------------------------------------------------------------
  def set_item(result, item, &callback)
    base_width = self.width
    @result_item = item
    @result = result
    contents.clear
    change_color(text_color(0))
    draw_text(0, 0, contents_width, line_height, "Upgrading...", 1)
    color1 = Color.new(235, 179, 59)
    color2 = Color.new(235, 112, 59)
    color3 = Color.new(0, 0, 0, 150)
    rate = 0
    wait = 60
    wait.times do |i|
      contents.clear_rect(0, line_height, contents_width, line_height)
      contents.fill_rect(0, line_height, contents_width, line_height, color3)
      contents.gradient_fill_rect(2, line_height + 2, (contents_width - 4) * (i / wait.to_f), line_height - 4, color1, color2)
      SceneManager.scene.update
    end
    close
    while self.openness > 0
      SceneManager.scene.update
    end
    result_text = result ? "Upgrade successfully!" : "Upgrade fail!"
    new_width = text_size(item.name).width + 32 + 32
    new_width = [new_width, text_size(result_text).width + 32].max
    self.width = new_width
    self.x = (Graphics.width - self.width) / 2
    create_contents
    refresh
    if result
      change_color(text_color(3))
      draw_text(0, line_height, contents_width, line_height, result_text)
      DSIVER144::EQUIP_UPGRADE::SUCCESS_ME.play
    else
      change_color(text_color(10))
      draw_text(0, line_height, contents_width, line_height, result_text)
      DSIVER144::EQUIP_UPGRADE::FAIL_ME.play
    end
    open
    while self.openness < 255
      SceneManager.scene.update
    end
    60.times do
      if Input.trigger?(:C)
        break
      end
      SceneManager.scene.update
    end
    close
    callback.call if callback
    self.width = base_width
    self.x = (Graphics.width - self.width) / 2
    create_contents
  end
  #--------------------------------------------------------------------------
  # * Item Rect
  #--------------------------------------------------------------------------
  def item_rect(index)
    return super(index)
  end
  #--------------------------------------------------------------------------
  # * Draw Item Number
  #--------------------------------------------------------------------------
  def draw_item_number(rect, item)
  end
  #--------------------------------------------------------------------------
  # * Make Item LIst
  #--------------------------------------------------------------------------
  def make_item_list
    @data = [@result_item]
  end
  #--------------------------------------------------------------------------
  # * Col Max
  #--------------------------------------------------------------------------
  def col_max
    return 1
  end

end

class Window_FreeUpgradeItemList < Window_ItemList
  #--------------------------------------------------------------------------
  # * Col Max
  #--------------------------------------------------------------------------
  def col_max
    return 1
  end
  #--------------------------------------------------------------------------
  # * Make Item LIst
  #--------------------------------------------------------------------------
  def make_item_list
    @data = $game_party.all_items.select {|item| item.free_upgrade}
  end
end