[RGSS/2] DRG Inventory System

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# DRG Inventory System
# Version: 2.04
# Author : LiTTleDRAgo
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
($imported ||={})[:drg_inv_sys] = $drg_inv_sys = 2.04
module LiTTleDRAgo
#==============================================================================
# *** EDITABLE SECTION
#==============================================================================
  NONDISCARD = {0 => [23,24,25,50,51,52],   # item nondiscardable
                1 => [],                    # weapon nondiscardable
                2 => []}                    # armor nondiscardable

  DEFAULT_MAX_SIZE   = 10 # Max size inventory default (can be changed in game)

  DEFAULT_ITEM_STACK = {   # Max Item stack
            0 => 90,       # For All Unlisted Item
            3 => 80,       # For item ID 3 (Full Potion)
  }

  #------------------------------------------------------------
  #*** ADDITIONAL SECTION (Can be deleted)
  #------------------------------------------------------------
  #------------------------------------------------------
  # COMBINE ITEM (Reference : Resident Evil series)
  # Format
  #  'Item(ID-1) + Item(ID-2)' => 'Item(ID-Result)'
  #------------------------------------------------------
  # delete if you don't want to use it

  COMBINE_ITEM = {

    'Item(1) + Item(1)'     => 'Item(2)',
    'Item(1) + Item(2)'     => 'Item(3)',

      # Means :
      # Item ID 1 (potion) + Item ID 1 (potion)   => Item ID 2 (Hipotion)
      # Item ID 1 (potion) + Item ID 2 (Hipotion) => Item ID 3 (Fullpotion)
      #------------------------------------------------------

    'Item(1) + Weapon(1)'   => 'Weapon(2)',
    'Weapon(1) + Weapon(2)' => 'Weapon(3)',
    'Weapon(1) + Armor(1)'  => 'Weapon(4)',

  }

  SOUND_COMBINE = '055-Right01' # SE Used when combining item
  # end delete

  #------------------------------------------------------
  # RARITY SISTEM
  # Format
  # Type = { ID Item => Star (max 8) }
  #------------------------------------------------------
  # delete if you don't want to use it
  RARITY = {

    'Item'   => {
                  1 => 1,
                  2 => 3,
                },
      # Means :
      # Item ID 1 (potion)     will have 1 star
      # Item ID 2 (Hipotion)   will have 3 star
      #------------------------------------------------------
    'Weapon' =>  {
                  1 => 2,
                  2 => 3,
                 },

    'Armor' => {
                  1 => 2,
                  2 => 3,
                },

  }
  # end delete

  #------------------------------------------------------------
  # *** ADDITIONAL SECTION END
  #------------------------------------------------------------

  #------------------------------------------------------------
  #                            EDITABLE DETAIL
  #------------------------------------------------------------

  BACKGROUND  = 'Mn_Back'     # Animated background graphic
  TRAN_TIME   = 20            # Transition Time
  TRAN_TYPE   = "004-Blind04" # Transition Type (Name)

  # STRING SECTION
  ITEM_WELCOME     = "In %s's Bag"
  EQUIP_WELCOME    = "Press Shift button to Unequip"
  ASK_MANY         = "How Many?"
  GET_COMB         = "Get %2$s x %1$s"
  PARTY_INV        = "%s's Inventory"
  LOOT_INV         = "Discarded Item"
  USE_COM          = "Use"
  COMBINE_COM      = "Combine"     # Insert nil to disable permanently
  EQ_COM           = nil           # Insert nil to disable permanently
  TRANSFER_COM     = "Transfer"    # Insert nil to disable permanently
  UNEQUIP_COM      = "Unequip"
  UNEQUIPALL_COM   = "Unequip All"
  DIS_COM          = "Discard"
  CANCEL_COM       = "Cancel"
  FULL_INVENTORY   = 'Inventory is full'
  ELEMENT_TOO_MANY = 'Too Complex'

  MAIN_INVENTORY_LEADER = true   # Main inventory is always set to party leader
                                 # when changing party
                                 # (won't do a thing if TRANSFER_COM is nil)
  ELEMENT_STATUS_MARQUEE = true  # using marque text if element or status
                                 # effect is too many to show
  SHOW_ITEM_STACK = true         # show max item stack in inventory?
                                 # ex : Potion 1/80
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # You can disable combine and equip feature by using script call
  #
  #       $game_party.disable_combine = true / false
  #       $game_party.disable_equip = true / false
  #
  # You can change the inventory size by using script call
  #
  #       $game_party.resize_inventory(new_size)
  #
  # You can switch the main inventory with the call script
  #
  #       $game_party.switch_inventory(ID_Actor)
  #
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#==============================================================================
# *** END of EDITABLE SECTION
#==============================================================================
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================
if $imported[:drg_inv_sys]
  VX  = defined?(Window_ActorCommand)
  VXA = defined?(Window_BattleActor)
  raise "This script is only for RMXP" if VX or VXA

  class Window_Base < Window
    #--------------------------------------------------------------------------
    # * Draw Icon
    #--------------------------------------------------------------------------
    define_method(:cache) { VX ? Cache : RPG::Cache }
    def draw_icon_vx_a(file_name,icon_index, x, y, enabled = true)
      bitmap = cache.picture(file_name.to_s)
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      self.contents.blt(x, y, bitmap, rect, enabled ? 255 : 128)
    end
    #--------------------------------------------------------------------------
    # * Draw Icon
    #--------------------------------------------------------------------------
    def draw_icon_vx(icon_index=1, x=0, y=0, enabled = true)
      bitmap = cache.system("Iconset")
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      self.contents.blt(x, y, bitmap, rect, enabled ? 255 : 128)
    end
  end

  #==============================================================================
  # ** Window_Selectable_Drago / Window_Command
  #------------------------------------------------------------------------------
  #
  #==============================================================================
  class Window_Selectable_Drago < Window_Selectable; end unless VX
  Class = [:Equip,:Battle,:Menu].map {|s| :"Scene_#{s}"}
  Class = [:"#{VX ? 'Game_' : ''}Interpreter", Class ,:Window_Command] +
        [:Spriteset_Map].map {|s| :"#{s}_Drago < #{s}"}
  #==============================================================================
  # ** Window_Welcome
  #------------------------------------------------------------------------------
  #  Window for the welcome at the top.
  #==============================================================================

  class Window_Welcome < Window_Base
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize(about = nil)
      case about
      when nil,'help'
        super(0, 0, 640, 64)
      when 'statistic'
        super(352, 64, 288, 416)
      end
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = "Sylfaen"
      refresh if about == nil
    end

    def resize_window(w = width, h = height)
      self.width  = w
      self.height = h
    end

    def refresh(x=nil)
      self.contents.clear
      @text,@align = "#{$game_party.limit_inventory.slots.size} / " +
              "#{$game_party.limit_inventory.max_size}",4
      return self.contents.draw_text(0, 0, 255, 32,  x.to_s, 4) if !x.nil?
      actor = $game_actors[$game_party.inventory].name rescue ''
      text = sprintf(LiTTleDRAgo::ITEM_WELCOME,actor)
      self.contents.draw_text(0, 0, 255, 32,  text, 4)
      if $game_party.limit_inventory.nil?
        $game_party.limit_inventory =
        Game_LimitedInventory.new(LiTTleDRAgo::DEFAULT_MAX_SIZE)
      end
      self.contents.draw_text(550,0,100,32, @text ,@align )
    end
    #--------------------------------------------------------------------------
    # * Set Text
    #--------------------------------------------------------------------------
    def set_text(text, align = 0,item=nil)
      if text != @text or align != @align
        self.contents.clear
        self.contents.font.color = normal_color
        if defined?(LiTTleDRAgo.ItemColor) && !item.nil?
          color = case item
          when RPG::Item   then LiTTleDRAgo.ItemColor  (item.id)
          when RPG::Weapon then LiTTleDRAgo.WeaponColor(item.id)
          when RPG::Armor  then LiTTleDRAgo.ArmorColor (item.id)
          end
        end
        self.contents.font.color = color if !color.nil?
        draw_colored_words(4, 0, self.width - 40, 32, text, align)
        @text,@align = text, align
      end
    end
    #--------------------------------------------------------------------------
    # * Draw Colored Words
    #--------------------------------------------------------------------------
    def draw_colored_words(x,y,width,height,message='',align=0)
      xx = [0, self.contents.font.color.dup]
      t = message.clone
      t.gsub!(/ : /) { "\001[0] : " }
      t.gsub!(/\\[Cc]\[([0-9]+)\]/) { "\001[#{$1}]" }
      while ((c = t.slice!(/./m)) != nil)
        if c == "\001"
          t.sub!(/\[([0-9]+)\]/, "")
          self.contents.font.color = text_color($1.to_i)
          next
        end
        self.contents.draw_text(x + xx[0], y, width, height, c)
        xx[0] += self.contents.text_size(c).width
      end
      self.contents.font.color = xx[1]
    end
  end #of class
  #==============================================================================
  # ** Window_Target_Drago
  #------------------------------------------------------------------------------
  #  This window selects a use target for the actor on item and skill screens.
  #==============================================================================
  class Window_Target_Drago < Window_Selectable_Drago
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize
      super(202, 170, 288, 160)
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = "Sylfaen"
      self.z += 10
      @item_max = $game_party.actors.size
      @column_max = 4
    end
    #--------------------------------------------------------------------------
    # * Cursor Rectangle Update
    #--------------------------------------------------------------------------
    define_method(:refresh) { update_cursor_rect }
    def update_cursor_rect
      self.contents.clear
      for i in 0...$game_party.actors.size
        x = 10 + i * 60
        y = 0
        actor = $game_party.actors[i]
        draw_actor_name(actor, x, y)
        draw_actor_graphic(actor, x + 20, y + 80)
        draw_actor_level(actor, x, y + 66)
      end
      actor = $game_party.actors[self.index]
      x = y = 0
      draw_actor_hp(actor, x + 60, y + 86)
      VX ? draw_actor_mp(actor, x + 60, y + 106) :
        draw_actor_sp(actor, x + 60, y + 106)
      if @index <= -2
        self.cursor_rect.set(0, (@index + 10) * 60, 60, 96)
      elsif @index == -1
        self.cursor_rect.set(0, 0, 60, @item_max * 116 - 20)
      else
        self.cursor_rect.set(@index * 60, 0, 60, 96)
      end
    end
    #--------------------------------------------------------------------------
    # * Draw Level2
    #--------------------------------------------------------------------------
    def draw_actor_level(actor, x, y)
      self.contents.font.color = system_color
      self.contents.draw_text(x, y, 32, 32, "Lv:")
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 16, y, 24, 32, actor.level.to_s, 2)
    end
  end
  #==============================================================================
  # ** RPG::Item
  #------------------------------------------------------------------------------
  #  This class is core of item module
  #==============================================================================
  ['Item','Armor','Weapon'].each {|s| eval "
  class RPG::#{s}
    alias_method(:drg123_name, :name)
    define_method(:name) { true_name.clone.gsub(/\\[Cc]\[([0-9]+)\]/) { '' }}
    define_method(:true_name) { drg123_name}
  end#"}

  #==============================================================================
  # ** Bitmap
  #------------------------------------------------------------------------------
  #  This class is for slice text method
  #==============================================================================
  class Bitmap
    def slice_text(text, width)
      words = text.split(' ')
      return words if words.size == 1
      result, current_text = [], words.shift
      words.each_index {|i|
          if self.text_size("#{current_text} #{words[i]}").width > width
            result.push(current_text)
            current_text = words[i]
          else
            current_text = "#{current_text} #{words[i]}"
          end
          result.push(current_text) if i >= words.size - 1}
      return result
    end
  end
  #==============================================================================
  # ** Scene_Item
  #------------------------------------------------------------------------------
  #  This class performs item screen processing.
  #==============================================================================

  class Scene_Item
    #--------------------------------------------------------------------------
    # * Stats Text Update
    #--------------------------------------------------------------------------
    def update_stats
      @x = @y = 0
      unless @hp_word
        @hp_word    = VX ? "#{Vocab.hp} :"    : "#{$data_system.words.hp} :"
        @sp_word    = VX ? "#{Vocab.mp} :"    : "#{$data_system.words.sp} :"
        @str_word   = VX ? ''                 : "#{$data_system.words.str} :"
        @dex_word   = VX ? ''                 : "#{$data_system.words.dex} :"
        @agi_word   = VX ? "#{Vocab.agi} :"   : "#{$data_system.words.agi} :"
        @int_word   = VX ? "#{Vocab.spi} :"   : "#{$data_system.words.int} :"
        @atk_word   = VX ? "#{Vocab.atk} :"   : "#{$data_system.words.atk} :"
        @pdef_word  = VX ? "#{Vocab.def} :"   : "#{$data_system.words.pdef} :"
        @mdef_word  = VX ? ''                 : "#{$data_system.words.mdef} :"
        @guard_word = VX ? "#{Vocab.guard} :" : "#{$data_system.words.guard} :"
      end
      if @item_window[0].active && @item_window[0].item != 0
        @item = @item_window[0].item
        update_item
      elsif @item_window[1].active &&  @item_window[1].item != 0
        @item = @item_window[1].item
      end
      case @item
      when RPG::Item   then update_item_values('Item')   if window_index_update?
      when RPG::Weapon then update_item_values('Weapon') if window_index_update?
      when RPG::Armor  then update_item_values('Armor')  if window_index_update?
      end
      update_guardset_status
    end
    def window_index_update?
      if @must_update
        @must_update = nil
        return true
      elsif @item_window[0].active && @old_index != @item_window[0].index
        @old_index = @item_window[0].index
        return true
      elsif @item_window[1].active && @old_index != @item_window[1].index
        @old_index = @item_window[1].index
        return true
      end
      return false
    end
    #--------------------------------------------------------------------------
    # * Set Rarity
    #--------------------------------------------------------------------------
    def set_rarity(about='',id=0)
      rarity = LiTTleDRAgo::RARITY rescue {}
      if rarity[about] != nil && rarity[about][id] != nil && !$drg_inv_sys_no_star
        rarity[about][id].abs.times do |i|
          src_rect = Rect.new(0, 0, 24, 24)
          cache = VX ? Cache : RPG::Cache
          icon = cache.icon('star') rescue 'no_icon'
          if icon == 'no_icon'
            opac = @item_window[2].opacity
            @item_window[2].opacity -= 150
            $drg_inv_sys_no_star = true
            report_missing_image('star.png','Icons')
            @item_window[2].opacity = opac
          else
            @sta_window['stat'].contents.blt(@x-32*i+230, @y + 24, icon, src_rect)
          end
        end
      end
    end
    #--------------------------------------------------------------------------
    # * Draw Colored Words
    #--------------------------------------------------------------------------
    def draw_colored_words(x,y,width,height,message='',a = 0)
      xx = [0, @sta_window['stat'].contents.font.color.dup]
      t = message.clone
      t.gsub!(/\\[Cc]\[([0-9]+)\]/) { "\001[#{$1}]" }
      while ((c = t.slice!(/./m)) != nil)
        if c == "\001"
          t.sub!(/\[([0-9]+)\]/, "")
          @sta_window['stat'].contents.font.color =
               @sta_window['stat'].text_color($1.to_i)
          next
        end
        @sta_window['stat'].contents.draw_text(x + xx[0],y,width,height,c) if a<10
        xx[0] += @sta_window['stat'].contents.text_size(c).width
      end
      @sta_window['stat'].contents.font.color = xx[1] if a<10
    end
    #--------------------------------------------------------------------------
    # * slice_col_words
    #--------------------------------------------------------------------------
    def slice_col_words(text, width)
      space = ' '
      words = text.split(space)
      return words if words.size == 1
      result, current_text = [], words.shift
      words.each_index {|i|
      t = "#{current_text}#{space}#{words}"
      if @sta_window['stat'].contents.text_size(t).width > width
        result.push(current_text)
        current_text = words[i]
      else
        current_text = "#{current_text}#{space}#{words[i]}"
      end
      result.push(current_text) if i >= words.size - 1}
      return result
    end
    #--------------------------------------------------------------------------
    # * Update Item Values
    #--------------------------------------------------------------------------
    def update_item_values(type='Item')
      @sta_window['stat'].contents.clear
      if defined?(G7_MS_MOD) && type == 'Armor' && @item.kind > 3
        add  = G7_MS_MOD::EXTRA_SLOT_NAMES[@item.kind-4]
      else
        add = type == 'Armor' ? (VX ? eval("Vocab.armor#{@item.kind + 1}") :
            $data_system.words.send("armor#{@item.kind + 1}")) : ''
      end
      add = " -> #{add}" if type == 'Armor'
      string = case type
        when 'Item' then ['Enhancements: ','Range: ','Recovery: ',
                          'Elements: ','Status Effects: ','','','','']
        when 'Weapon' then [ @atk_word, @pdef_word, @mdef_word,
                         @str_word, @dex_word, @agi_word, @int_word,
                        'Elements: ' ,'Status Effects: ']
        when 'Armor' then [@pdef_word, @mdef_word, 'EVA : ',
                       @str_word, @dex_word, @agi_word, @int_word,
                       'Guard Elements: ','Guard Effects: ']
        end
      vy = VX ? -60 : 0
      @sta_window['stat'].contents.font.color = Color.new(192, 224, 255, 255)
      @sta_window['stat'].contents.font.bold = true
      set_rarity(type,@item.id)
      @sta_window['stat'].contents.draw_text(@x,@y    ,212,32, "Name: "      )
      @sta_window['stat'].contents.draw_text(@x,@y+42 ,212,32, "Description:")
      @sta_window['stat'].contents.draw_text(@x,@y+106+6,212,32, "Item Type: " )
      @sta_window['stat'].contents.draw_text(@x,@y+140,212,32, "Statistics: ")
      size = @sta_window['stat'].contents.font.size
      @sta_window['stat'].contents.font.size -= 3
      @sta_window['stat'].contents.font.bold = false
      @sta_window['stat'].contents.font.color = Color.new(255, 255, 255, 255)
      bio = [@item.description.clone.gsub(/\\[Cc]\[([0-9]+)\]/) { '' },
            250]
      bio = @sta_window['stat'].contents.slice_text(*bio)
      if defined?(LiTTleDRAgo.ItemColor)
        color = case @item
        when RPG::Item   then LiTTleDRAgo.ItemColor  (@item.id)
        when RPG::Weapon then LiTTleDRAgo.WeaponColor(@item.id)
        when RPG::Armor  then LiTTleDRAgo.ArmorColor (@item.id)
        end
      end
      @sta_window['stat'].contents.font.color = color if !color.nil?
      @sta_window['stat'].contents.font.size = size
      draw_colored_words(@x+60,@y,212,32,@item.true_name)
      @sta_window['stat'].contents.font.size -= 3
      @sta_window['stat'].contents.font.color = Color.new(255, 255, 255, 255)
      bio.each_index {|i|
      @sta_window['stat'].contents.draw_text(@x,(@y+62)+i*15,250,32,bio[i])}
      @sta_window['stat'].contents.font.size = size
      @sta_window['stat'].contents.font.color = Color.new(255, 255, 255, 255)
      @sta_window['stat'].contents.draw_text(@x+95,@y+106+6,212,32,type+add,0)
      begin;  return if @item.card?;  rescue;  nil end
      @sta_window['stat'].contents.font.color = Color.new(192, 224, 255, 255)
      @sta_window['stat'].contents.draw_text(@x,@y+165   ,212,32,string[0])
      @sta_window['stat'].contents.draw_text(@x,@y+185   ,212,32,string[1])
      @sta_window['stat'].contents.draw_text(@x,@y+205   ,212,32,string[2])
      @sta_window['stat'].contents.draw_text(@x,@y+225   ,212,32,string[3])
      @sta_window['stat'].contents.draw_text(@x,@y+245   ,212,32,string[4])
      @sta_window['stat'].contents.draw_text(@x,@y+265+vy,212,32,string[5])
      @sta_window['stat'].contents.draw_text(@x,@y+285+vy,212,32,string[6])
      @sta_window['stat'].contents.draw_text(@x,@y+305+vy,212,32,string[7])
      @sta_window['stat'].contents.draw_text(@x,@y+325+vy,212,32,string[8])
      @sta_window['stat'].contents.font.color = Color.new(255, 255, 255, 255)
      if type == 'Item'
        text = [case @item.parameter_type
        when 0 then "None"
        when 1 then "Max #{@hp_word} + #{@item.parameter_points}"
        when 2 then "Max #{@sp_word} + #{@item.parameter_points}"
        when 3 then "#{@str_word} + #{@item.parameter_points}"
        when 4 then "#{@dex_word} + #{@item.parameter_points}"
        when 5 then "#{@agi_word} + #{@item.parameter_points}"
        when 6 then "#{@int_word} + #{@item.parameter_points}"
        end, case @item.scope
        when 0,1 then @item.scope == 0 ? "None"        : "One Enemy"
        when 2,3 then @item.scope == 2 ? "All Enemies" : "One Ally"
        when 4,5 then @item.scope == 4 ? "All Allies"  : "One Ally"
        when 6,7 then @item.scope == 6 ? "All Allies"  : "This User"
        end, VX ? [@item.hp_recovery, @item.mp_recovery] :
                  [@item.recover_hp, @item.recover_sp]].flatten
        @sta_window['stat'].contents.draw_text(@x+110,@y+165,212,32,text[0])
        @sta_window['stat'].contents.draw_text(@x+110,@y+185,212,32,text[1])
        @sta_window['stat'].contents.draw_text(@x+110,@y+205,212,32,"#{text[2]} HP")
        @sta_window['stat'].contents.draw_text(@x+180,@y+205,212,32,"#{text[3]} SP")
      else
        atk = type == 'Weapon' ? @item.atk : @item.eva
        pdef = VX ? "#{@item.def}" : @item.pdef
        mdef = VX ? '' : @item.mdef
        str = VX ? '' : @item.str_plus
        dex = VX ? '' : @item.dex_plus
        agi = VX ? @item.agi : @item.agi_plus
        int = VX ? @item.spi : @item.int_plus
        text = ["#{atk}","#{pdef}","#{mdef}","#{atk}"]
        text.shift if type == 'Armor'
        ev = type == 'Armor' ? vy/3 : 0
        @sta_window['stat'].contents.draw_text(@x+120,@y+165,212,32,text[0])
        @sta_window['stat'].contents.draw_text(@x+120,@y+185,212,32,text[1])
        @sta_window['stat'].contents.draw_text(@x+120,@y+205+ev,212,32,text[2])
        @sta_window['stat'].contents.draw_text(@x+120,@y+225,212,32,"#{str}")
        @sta_window['stat'].contents.draw_text(@x+120,@y+245,212,32,"#{dex}")
        @sta_window['stat'].contents.draw_text(@x+120,@y+265+vy,212,32,"#{agi}")
        @sta_window['stat'].contents.draw_text(@x+120,@y+285+vy,212,32,"#{int}")
      end
      guardset = [ case type
            when 'Item', 'Weapon' then @item.element_set
            when 'Armor' then VX ? @item.element_set : @item.guard_element_set
            end, case type
            when 'Item' then @item.plus_state_set
            when 'Weapon' then VX ? @item.state_set : @item.plus_state_set
            when 'Armor' then VX ? @item.state_set : @item.guard_state_set
            end]
      @element = @status = ''
      guardset[0].each_with_index {|i,s| @element += ", " if s > 0
                                    @element += $data_system.elements[i] }
      guardset[1].each_with_index {|i,s| @status += ", " if s > 0
                                    @status += $data_states[i].name }
      @element = 'None' if @element == ''
      @element += ', ' if  @element.size > 20
      @status = 'None' if @status == ''
      @status += ', '  if @status.size > 20
      pos = type == 'Item' ? [@x+110,@y+230] : [@x+120,@y+310+vy]
      @sta_window['stat'].contents.draw_text(pos[0],pos[1],420,24,@element)
      @sta_window['stat'].contents.draw_text(pos[0],pos[1]+20,420,24,@status)
    end
    #--------------------------------------------------------------------------
    # * Update guardset status
    #--------------------------------------------------------------------------
    def update_guardset_status
      @time_status = (@time_status || 0) + 1
      return if @item.nil? || @time_status < 8
      vy,@time_status = VX ? -60 : 0 ,0
      pos = @item.is_a?(RPG::Item) ? [@x+110,@y+230] : [@x+120,@y+310+vy]
      kuu = LiTTleDRAgo::ELEMENT_TOO_MANY
      if  @element != nil && @element.size > 20
        rect = Rect.new(pos[0], pos[1], @sta_window['stat'].width  - 32, 24)
        if LiTTleDRAgo::ELEMENT_STATUS_MARQUEE
          @sta_window['stat'].contents.fill_rect(rect, Color.new(0, 0, 0, 0))
          array = @element.split(//)
          array << array[0]
          array.shift
          @element = array.join
          @sta_window['stat'].contents.draw_text(pos[0],pos[1],420,24,@element)
        else
          @sta_window['stat'].contents.fill_rect(rect, Color.new(0, 0, 0, 0))
          @sta_window['stat'].contents.draw_text(pos[0],pos[1],420,24,kuu)
        end
      end
      if  @status != nil && @status.size > 20
        rect = Rect.new(pos[0], pos[1]+20, @sta_window['stat'].width  - 32, 24)
        if LiTTleDRAgo::ELEMENT_STATUS_MARQUEE
          @sta_window['stat'].contents.fill_rect(rect, Color.new(0, 0, 0, 0))
          array = @status.split(//)
          array << array[0]
          array.shift
          @status = array.join
          @sta_window['stat'].contents.draw_text(pos[0],pos[1]+20,420,24,@status)
        else
          @sta_window['stat'].contents.fill_rect(rect, Color.new(0, 0, 0, 0))
          @sta_window['stat'].contents.draw_text(pos[0],pos[1]+20,420,24,kuu)
        end
      end
    end
  end #of class
  #==============================================================================
  # ** Game_Actor
  #------------------------------------------------------------------------------
  #  This class handles the actor. It's used within the Game_Actors class
  #  ($game_actors) and refers to the Game_Party class ($game_party).
  #==============================================================================
  class Game_Actor < Game_Battler
    @@equip = VX ? 'change_equip' : 'equip'
    eval "
    alias drg146_equip #{@@equip} unless method_defined?(:drg146_equip)
    def equip_fix?(*args) fix_equipment end if VX
    def #{@@equip}(*args)
      max = $game_party.limit_inventory.max_size
      $game_party.limit_inventory.resize (max+1)
      drg146_equip(*args)
      $game_party.limit_inventory.resize (max)
    end#"
  end
  #==============================================================================
  # ** Game_Temp
  #------------------------------------------------------------------------------
  #  This class handles temporary data that is not included with save data.
  #  Refer to "$game_temp" for the instance of this class.
  #==============================================================================
  class Game_Temp
    alias_method :drg137_init, :initialize unless method_defined?(:drg137_init)
    attr_accessor :slots_to_discard, :inventory
    define_method(:initialize) { [drg137_init,
                           @slots_to_discard = Game_LimitedInventory.new(-1)] }
  end
  #==============================================================================
  # ** Game_Party
  #------------------------------------------------------------------------------
  #  This class handles the party. It includes information on amount of gold
  #  and items. Refer to "$game_party" for the instance of this class.
  #==============================================================================
  class Game_Party
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Public Instance Variables
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    attr_reader :inventories
    attr_accessor :inventory,:gold,:disable_combine,:disable_equip
    attr_accessor :no_multi_use
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Aliased Method
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    unless method_defined?(:drg146_can_use)
      alias drg146_init initialize
      alias drg146_can_use item_can_use?
      alias drg146_number item_number
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Object Initialization
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def initialize(*args)
      drg146_init(*args)
      init_multi_inventory
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Object Initialization
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def limit_inventory(id=@inventory,val=nil)
      @limit_inventory = {} if @limit_inventory.nil?
      if @limit_inventory[id].nil?
        @limit_inventory[id] =
            Game_LimitedInventory.new(LiTTleDRAgo::DEFAULT_MAX_SIZE)
      end
      return val ? @limit_inventory[id] = val : @limit_inventory[id]
    end

    def stack_item(item_id)
      stack = LiTTleDRAgo::DEFAULT_ITEM_STACK
      return stack[item_id] || stack[0]
    end

    if VX
      def actors() members end
      def weapon_number(v) item_number($data_weapons[v]) end
      def armor_number(v) item_number($data_armors[v]) end
      def item_can_use?(item)
        item = $data_items[item] if item.is_a?(Integer)
        drg146_can_use(item)
      end
      def item_number(item)
        item = $data_items[item] if item.is_a?(Integer)
        drg146_number(item)
      end
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Gain Item (or Lose)
    #       item  >> item / item_id
    #       n     >> number
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def drg137_gain_item(id, n)
      @items[id] = [item_number(id) + n, 0].max if id > 0
    end
    def drg137_gain_weapon(id, n)
      @weapons[id] = [weapon_number(id) + n, 0].max if id > 0
    end
    def drg137_gain_armor(id, n)
      @armors[id] = [armor_number(id) + n, 0].max if id > 0
    end

    def gain_item(item, n, include_equip = false)
      return if item.nil?
      case item
      when RPG::Item, Numeric
        array = item.is_a?(RPG::Item) ? [item,item.id] : [$data_items[item],item]
        ammount = n
        while ammount > 1
          gain_proses(array[0], 1)
          drg137_gain_item(array[1], 1)
          ammount -= 1
        end
        gain_proses(array[0], ammount)
        drg137_gain_item(array[1], ammount)
      when RPG::Weapon then gain_weapon(item.id, n)
      when RPG::Armor  then gain_armor(item.id, n)
      end
      return unless VX
      number = item_number(item)
      n += number
      if include_equip and n < 0
        for actor in actors
          while n < 0 and actor.equips.include?(item)
            actor.discard_equip(item)
            n += 1
          end
        end
      end
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Gain Weapon And Armor (or Lose)
    #       item_id  >> weapon / armor id
    #       n        >> number
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def gain_weapon(item_id, n)
      ammount = n
      while ammount > 1
        drg137_gain_weapon(item_id, 1)
        gain_proses($data_weapons[item_id],1)
        ammount -= 1
      end
      drg137_gain_weapon(item_id, ammount)
      gain_proses($data_weapons[item_id],ammount)
    end

    def gain_armor(item_id, n)
      ammount = n
      while ammount > 1
        drg137_gain_armor(item_id, 1)
        gain_proses($data_armors[item_id],1)
        ammount -= 1
      end
      drg137_gain_armor(item_id, ammount)
      gain_proses($data_armors[item_id],ammount)
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Reduce_Item (for synchronize default item number and limited item number)
    #       item  >> item
    #       n     >> number
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def reduce_item(item, n)
      case item
      when RPG::Item then  drg137_gain_item(item.id, -n)
      when RPG::Weapon then drg137_gain_weapon(item.id, -n)
      when RPG::Armor then drg137_gain_armor(item.id, -n)
      end
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Gain Proses
    #       item  >> item
    #       n     >> number
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def gain_proses(item,n)
      init_multi_inventory if @inventories.nil?
      return if item == nil
      type = item.is_a?(RPG::Item) ? 0 : item.is_a?(RPG::Weapon) ? 1 : 2
      if n > 0
        n2 = limit_inventory.add_item(type, item.id, n)
        n -= n2
        if LiTTleDRAgo::NONDISCARD[type].include?(item.id)
          while n2 > 0
            for i in 0...limit_inventory.slots.size
              x = limit_inventory.slots.size - 1 - i
              slot = limit_inventory.slots[x]
              if !LiTTleDRAgo::NONDISCARD[slot.item_type].include?(slot.item_id)
                l_type, id = slot.item_type, slot.item_id
                while l_type == slot.item_type && id == slot.item_id
                  x -= 1
                  slot = limit_inventory.slots[x]
                end
                l_item, l_n = limit_inventory.slots[x + 1].item, limit_inventory.slots[x + 1].amount
                break
              end
            end
            return if l_item.nil? or l_n.nil?
            gain_proses(l_item, -1*l_n)
            $game_temp.slots_to_discard.add_item(l_type, id, l_n)
            n3 = limit_inventory.add_item(type, item.id, n2)
            n -= n3
            n2 = n3
          end
        end
      else
        n2 = limit_inventory.remove_item(type, item.id, -1*n)
        n += n2
        n2 *= -1
      end
      if n2 > 0
        $game_temp.slots_to_discard.add_item(type, item.id, n2)
      elsif n2 < 0
        $game_temp.slots_to_discard.remove_item(type, item.id, -1*n2)
      end
    end
    #--------------------------------------------------------------------------
    # * Item Number
    #--------------------------------------------------------------------------
    def all_item_number(item)
      case item
      when RPG::Item   then item_number(item.id)
      when RPG::Weapon then weapon_number(item.id)
      when RPG::Armor  then armor_number(item.id)
      end
    end

    def transfer_item(item, n, invent, target)
      item = $data_items[item] if item.is_a?(Integer)
      transfer_process(item, n, invent, target)
    end

    def transfer_weapon(item, n, invent, target)
      item = $data_weapons[item] if item.is_a?(Integer)
      transfer_process(item, n, invent, target)
    end

    def transfer_armor(item, n, invent, target)
      item = $data_armors[item] if item.is_a?(Integer)
      transfer_process(item, n, invent, target)
    end

    def transfer_process(item, n, invent, target)
      return if item.nil? || invent == target || n < 0
      type = item.is_a?(RPG::Item) ? 0 : item.is_a?(RPG::Weapon) ? 1 : 2
      d = @inventory
      stack = item.is_a?(RPG::Item) ? stack_item(item.id) : 1
      n.times {
        slot = limit_inventory(target).slots
        limit_max = limit_inventory(target).max_size
        number =  all_item_number(item)
        unless slot.size >= limit_max && (number <= 0 || (number % stack) == 0)
          switch_inventory(invent)
          if all_item_number(item) >= 1
            gain_item(item, -1)
            switch_inventory(target)
            gain_item(item, 1)
          end
        end}
      switch_inventory(d)
    end
    #--------------------------------------------------------------------------
    # * Initialize Multi Inventory
    #--------------------------------------------------------------------------
    def init_multi_inventory
      @inventory ||= @actors[0] ? @actors[0].id : nil
      @inventory ||= $data_system.party_members[0] || 1
      @inventories ||= [[@items, @weapons, @armors, @gold]]
    end
    #--------------------------------------------------------------------------
    # * Switch Inventory
    #--------------------------------------------------------------------------
    def switch_inventory(id)
      return if @inventory == id
      init_multi_inventory if @inventories.nil?
      new_inventory = @inventories[id] || [{}, {}, {}, 0]
      @inventories[@inventory] = [@items, @weapons, @armors, @gold]
      @items   = new_inventory[0]
      @weapons = new_inventory[1]
      @armors  = new_inventory[2]
      @gold    = new_inventory[3]
      @inventory = id
    end
    #--------------------------------------------------------------------------
    # * Destroy Inventory
    #--------------------------------------------------------------------------
    def destroy_inventory(id=0)
      init_multi_inventory if @inventories.nil?
      @inventories[id] = [{}, {}, {}, 0]
      return unless @inventory == id
      @items,@weapons,@armors,@gold = {}, {}, {}, 0
      limit_inventory.clear
    end
    #--------------------------------------------------------------------------
    # * Resize Inventory
    #--------------------------------------------------------------------------
    def resize_inventory(new_size)
      $game_party.limit_inventory.resize(new_size)
    end
    #--------------------------------------------------------------------------
    # * Combine Inventory
    #--------------------------------------------------------------------------
    def combine_inventory(base_id, merge_id, overflow = false)
      base_id = @inventory if base_id == nil
      base, merge = @inventories[base_id], @inventories[merge_id]
      base_items, base_weapons, base_armors, base_gold = base
      items, weapons, armors, gold = merge
      items.each do |item_id, amount|
        number = base_items[item_id].to_i + amount
        items[item_id] = overflow && number > 99 ? number - 99 : 0
        base_items[item_id] = overflow && number > 99 ? 99 : number
      end
      weapons.each do |weapon_id, amount|
        number = base_weapons[weapon_id].to_i + amount
        weapons[weapon_id] = overflow && number > 99 ? number - 99 : 0
        base_weapons[weapon_id] = overflow && number > 99 ? 99 : number
      end
      armors.each do |armor_id, amount|
        number = base_armors[armor_id].to_i + amount
        armors[armor_id] = overflow && number > 99 ? number - 99 : 0
        base_armors[armor_id] = overflow && number > 99 ? 99 : number
      end
      number = base_gold + gold
      base[3] = overflow && number > 9999999 ? 9999999 : number
      merge[3] = overflow && number > 9999999 ? number - 9999999 : 0
    end
  end
  #==============================================================================
  # ** Scene_Menu
  #------------------------------------------------------------------------------
  #  This class performs menu screen processing.
  #==============================================================================
  Class.flatten.each_with_index {|h,i|
     j = [:command,:status,:actor].collect {|k|
      :"update_#{ k }#{ VX ? '_selection' : '' }" }
  eval "
  class #{h}
    attr_accessor :commands if #{i} == 4
    if #{i} == 0
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      # * Resize Inventory (change inventory size)
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      def resize_inventory(new_size)
        $game_party.limit_inventory.resize(new_size)
      end
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      # * Command End
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      unless method_defined?(:drg150_com_end) || !method_defined?(:command_end)
        alias drg150_com_end command_end
        alias drg150_com_129 command_129
      end
      define_method(:command_end) { [drg150_com_end,check_discard_item] }
      #--------------------------------------------------------------------------
      # * Change Party Member
      #--------------------------------------------------------------------------
      def command_129
        result = drg150_com_129
        leader = $game_party.actors.compact.first
        if (LiTTleDRAgo::MAIN_INVENTORY_LEADER &&
          LiTTleDRAgo::TRANSFER_COM) && !leader.nil?
          $game_party.init_multi_inventory
          $game_party.switch_inventory(leader.id)
        end
        return result
      end
      #--------------------------------------------------------------------------
      # * check_discard_item
      #--------------------------------------------------------------------------
      def check_discard_item
        $scene = Scene_Loot.new  unless $game_temp.slots_to_discard.slots.empty?
      end
      #next
    end
    if #{i} == 5
      #--------------------------------------------------------------------------
      # * Create Viewport
      #--------------------------------------------------------------------------
      def create_viewports
        @viewport1 = Viewport.new(0, 0, 640, 480)
        @viewport2 = Viewport.new(0, 0, 640, 480)
        @viewport3 = Viewport.new(0, 0, 640, 480)
        @viewport2.z, @viewport3.z = 50, 100
      end
      #next
    end
    if [1,2,3].include?(#{i})
      #--------------------------------------------------------------------------
      # * Alias Listing
      #--------------------------------------------------------------------------
      alias drg137_main main unless method_defined?(:drg137_main)
      alias drg137_batend battle_end unless method_defined?(:drg137_batend) ||
                                           !method_defined?(:battle_end)
      if LiTTleDRAgo::TRANSFER_COM && #{i} == 3
        alias drg150_upd_com #{j[0]} unless method_defined?(:drg150_upd_com)
        alias drg150_upd_sta #{!VX ? j[1] : j[2]} unless method_defined?(:drg150_upd_sta)
        #--------------------------------------------------------------------------
        # * Frame Update (when command window is active)
        #--------------------------------------------------------------------------
        def #{j[0]}
          if Input.trigger?(Input::C) && $game_party.actors.size > 0
            if @command_window.index == 0
              sound_play('decision')
              if $game_party.actors.size == 1
                $scene = Scene_Item.new($game_party.actors[0].id)
                return
              end
              20.times {[Graphics,Input].each {|s| s.update }}
              @command_window.active = false
              @status_window.active = true
              @status_window.index = 0
              return
            end
          end
          drg150_upd_com
        end
        #--------------------------------------------------------------------------
        # Sound Play
        #--------------------------------------------------------------------------
        def sound_play(se)
          case se
          when 'cursor'
            VX ? Sound.play_cursor : $game_system.se_play($data_system.cursor_se)
          when 'cancel'
            VX ? Sound.play_cancel : $game_system.se_play($data_system.cancel_se)
          when 'equip'
            VX ? Sound.play_equip : $game_system.se_play($data_system.equip_se)
          when 'use_item'
            VX ? Sound.play_use_item : $game_system.se_play(@item.menu_se)
          when 'decision'
            VX ? VXA ? Sound.play_ok : Sound.play_decision :
            $game_system.se_play($data_system.decision_se)
          when 'buzzer'
            VX ? Sound.play_buzzer : $game_system.se_play($data_system.buzzer_se)
          end
        end
        #--------------------------------------------------------------------------
        # * Frame Update (when status window is active)
        #--------------------------------------------------------------------------
        def #{!VX ? j[1] : j[2]}
          if Input.trigger?(Input::C) && @command_window.index == 0
            if @status_window.active
              item = $game_party.actors[@status_window.index].id
              sound_play('decision')
              return $scene = Scene_Item.new(item)
            end
          end
          drg150_upd_sta
        end
      end
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      # * Main
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      def main
        drg137_main
        $scene = Scene_Loot.new if !$game_temp.slots_to_discard.slots.empty?
      end if #{i} == 1
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      # * battle_end
      #     open up loot management if inventory is full in the end of battle
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      def battle_end(result)
        drg137_batend(result)
        if !$game_temp.slots_to_discard.slots.empty? && !$scene.is_a?(Scene_Gameover)
          $scene = Scene_Loot.new
        end
      end if #{i} == 2
    end
  end#"}

  #==============================================================================
  # ** Game LimInvSlot
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  #  This class holds the data on a single slot of the inventory
  #==============================================================================
  class Game_LimInvSlot
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Public Instance Variables
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    attr_reader   :item_type,:item_id,:amount
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Object Initialization
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def initialize
      @item_type = -1
      @item_id = 0
      @amount = 0
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Add Item
    #    n         >> the amount to add
    #    item_type >> the type of item being added
    #    item_id   >> the ID of item being added
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def add_item(n, item_type = -1, item_id = 0)
      if item_type != -1
        @item_type = item_type
        @item_id = item_id
      end
      if n > space_left
        @amount += space_left
        return n - space_left
      else
        @amount += n
        return 0
      end
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Remove Item
    #    n >> the amount to remove
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def remove_item(n)
      @amount -= n
      if @amount <= 0
        n = -1*@amount
        @item_type = -1
        @item_id = 0
        @amount = 0
        return n
      end
      return 0
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Item
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def item
      return case @item_type
      when -1 then nil
      when 0 then $data_items[@item_id]
      when 1 then $data_weapons[@item_id]
      when 2 then $data_armors[@item_id]
      end
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Space Left
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def space_left
      return 1 if item == nil
      return $game_party.stack_item(item.id) - @amount  if item.is_a?(RPG::Item)
      return 1 - @amount
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Equal?
    #    other : another Game_LimInvSlot
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def ==(other)
      return false if !other.is_a?(Game_LimInvSlot)
      return false if other.item_type != @item_type
      return false if other.item_id != @item_id
      return false if other.amount != @amount
      return super(other)
    end
  end

  #==============================================================================
  # ** Game_LimitedInventory
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  #  This is an array to store the party's inventory
  #==============================================================================
  class Game_LimitedInventory
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Public Instance Variable
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    attr_reader   :max_size
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Object Initialization
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def initialize(size)
      @max_size = size
      clear
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Clear
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def clear()  @items,@weapons,@armors = [],[],[] end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Resize
    #    size : the number of slots available
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def resize(size)
      old_size = slots.size
      if size < old_size
        index = slots.size - 1
        while slots.size > size
          slot = slots[index]
          if !LiTTleDRAgo::NONDISCARD[slot.item_type].include?(slot.item_id)
            type, id, n = slot.item_type, slot.item_id, slot.amount
            remove_item(type, id, n)
            $game_temp.slots_to_discard.add_item(type, id, n)
            index -= 1
          else
            index -= 1
          end
          break if index < 0
        end
      end
      @max_size = size
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Add Item
    #    type : the type of item being added
    #    id   : the ID of item being added
    #    n    : the amount to add
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def add_item(type, id, n = 1)
      array = case type
      when 0 then @items
      when 1 then @weapons
      when 2 then @armors
      end
      sort_index = 0
      array.each { |slot|
        if slot.item_id == id
          n = slot.add_item(n, type, id)
          break if n == 0
          sort_index += 1
        elsif slot.item_id < id
          sort_index += 1
        else
          break
        end }
      if n > 0
        while @max_size == -1 || ((@items.size + @weapons.size + @armors.size) < @max_size)
          slot = Game_LimInvSlot.new
          n = slot.add_item(n, type, id)
          array.insert(sort_index, slot)
          sort_index += 1
          break if n == 0
        end
      end
      return n
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Add Item
    #    type : the type of item being added
    #    id   : the ID of item being added
    #    n    : the amount to add
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def add_item_reverse(type, id, n = 1)
      array = case type
      when 0 then @items
      when 1 then @weapons
      when 2 then @armors
      end
      sort_index = 0
      array.reverse.each { |slot|
        if slot.item_id == id
          n = slot.add_item(n, type, id)
          break if n == 0
          sort_index += 1
        elsif slot.item_id < id
          sort_index += 1
        else
          break
        end }
      if n > 0
        while @max_size == -1 || ((@items.size + @weapons.size + @armors.size) < @max_size)
          slot = Game_LimInvSlot.new
          n = slot.add_item(n, type, id)
          array.insert(sort_index, slot)
          sort_index += 1
          break if n == 0
        end
      end
      return n
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Remove Item
    #    type : the type of item being removed
    #    id   : the ID of item being removed
    #    n    : the amount to remove
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def remove_item(type, id, n = 1)
      array = case type
      when 0 then @items
      when 1 then @weapons
      when 2 then @armors
      end
      array.reverse.each { |slot|
        if slot.item_type == type && slot.item_id == id
          n = slot.remove_item(n)
          array.delete(slot) if slot.amount == 0
          break if n == 0
        end }
      return n
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Remove Item
    #    type : the type of item being removed
    #    id   : the ID of item being removed
    #    n    : the amount to remove
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def remove_item_reverse(type, id, n = 1)
      array = case type
      when 0 then @items
      when 1 then @weapons
      when 2 then @armors
      end
      array.each { |slot|
        if slot.item_type == type && slot.item_id == id
          n = slot.remove_item(n)
          array.delete(slot) if slot.amount == 0
          break if n == 0
        end }
      return n
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Slots
    #    get all slot in the inventory
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def slots
      return @items + @weapons + @armors
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * slot
    #    get slot for the certain item
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def slot(item)
      array = @items
      array = @weapons if item.is_a?(RPG::Weapon)
      array = @armors if item.is_a?(RPG::Armor)
      for i in 0...array.size
        slot = array[i]
        break if slot.item_id == item.id
      end
      return slot
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * slot
    #    get slot for the certain item
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def slot_reverse(item)
      array = @items
      array = @weapons if item.is_a?(RPG::Weapon)
      array = @armors if item.is_a?(RPG::Armor)
      array.reverse!
      for i in 0...array.size
        slot = array[i]
        break if slot.item_id == item.id
      end
      return slot
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Check Space
    #    slot : an Game_InvSlot object
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def enough_space?(slot)
      return true if @max_size == -1 || slots.size < @max_size
      array = [@items, @weapons, @armors][slot.item_type]
      array.each { |i|
        if i.item_id > slot.item_id
          break
        elsif i.item_id == slot.item_id
          l = $game_party.stack_item(i.item_id)
          x = slot.item.is_a?(RPG::Item) ? l : 1
          break if i.space_left == 0
          return true if i.space_left < x
        end }
      return false
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Equals?
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def ==(other)
      return false unless other.is_a?(Game_LimitedInventory)
      return false if @max_size != other.max_size
      return false if slots != other.slots
      return super(other)
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Cek Amount
    #    cek amount of an item in the inventory
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def cek_amount(type, id)
      array = case type
      when 0 then @items
      when 1 then @weapons
      when 2 then @armors
      end
      @n = 0
      array.each { |slot|  @n += slot.amount if slot.item_id == id   }
      return @n
    end
  end

  #==============================================================================
  # ** Window_Item
  #------------------------------------------------------------------------------
  #  The Item Grid Window. Based off a 10 column coding.
  #==============================================================================
  class Window_Item_Fake_Grid < Window_Selectable_Drago
   #--------------------------------------------------------------------------
   # * Public Instance Variables
   #--------------------------------------------------------------------------
   attr_accessor :item,:item_max
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize(inventory = $game_party.limit_inventory,
                   discard = $game_temp.slots_to_discard )
      if inventory.is_a?(String)
        s = eval(inventory)
        inventory = nil
      else
        s = inventory.is_a?(Array) ? inventory.size :
             $game_party.limit_inventory.max_size
      end
      if s >= 35 &&  $scene.is_a?(Scene_Loot)
        super(55, 160, 200+32, 32*6)
        @column_max = 6
      else
        if s <= 6 then super(100, 200, 200-32*2, 32*3)
        elsif s <= 10 then super(100, 200, 200, 32*3)
        elsif s <= 15 then super(100, 200, 200, 32*4)
        elsif s <= 24 then super(80, 180, 200+32, 32*5)
        elsif s <= 30 then super(80, 160, 200+32, 32*6)
        elsif s <= 42 then super(60, 140, 200+32*2, 32*7)
        elsif s <= 49 then super(60, 120, 200+32*2, 32*8)
        elsif s <= 56 then super(40, 120, 200+32*3, 32*8)
        elsif s <= 64 then super(40, 100, 200+32*3, 32*9)
        elsif s <= 72 then super(20, 100, 200+32*4, 32*9)
        elsif s <= 81 then super(20, 70, 200+32*4, 32*10)
        elsif s <= 90 then super(0, 70, 200+32*5, 32*10)
        elsif s <= 100 then super(0, 70, 200+32*5, 32*10)
        elsif s <= 110 then super(0, 68, 200+32*5, 32*10)
        else super(0, 64, 200+32*5, 32*10)
        end
        if s <= 6 then @column_max = 3
        elsif s <= 10 then @column_max = 5
        elsif s <= 15 then @column_max = 5
        elsif s <= 24 then @column_max = 6
        elsif s <= 30 then @column_max = 6
        elsif s <= 42 then @column_max = 7
        elsif s <= 49 then @column_max = 7
        elsif s <= 56 then @column_max = 8
        elsif s <= 64 then @column_max = 8
        elsif s <= 72 then @column_max = 9
        elsif s <= 81 then @column_max = 9
        elsif s <= 90 then @column_max = 10
        elsif s <= 100 then @column_max = 10
        elsif s <= 110 then @column_max = 10
        else @column_max = 10
        end
      end
      @inventory = inventory
      return self.contents = Bitmap.new(width-32, height-32) if inventory == nil
      return self.contents = Bitmap.new(width-32, height-32) if discard == nil
      self.opacity = 0
      refresh
      self.index = 0
      if $game_temp.in_battle && !$BlizzABS
        self.x = 144
        self.y = 64
        self.back_opacity = 250
      end
    end
    #--------------------------------------------------------------------------
    # * Get Inventory
    #--------------------------------------------------------------------------
    def inventory() @inventory end
    #--------------------------------------------------------------------------
    # * Get Disabled Text Color
    #--------------------------------------------------------------------------
    def disabled_color() Color.new(255, 255, 255, 128) end
    #--------------------------------------------------------------------------
    # * Update Cursor Rectangle
    #--------------------------------------------------------------------------
    def update_cursor_rect
      return if @inventory == nil
      return  self.cursor_rect.empty if @index < 0
      row = @index / @column_max
      self.top_row = row if row < self.top_row
      if row > self.top_row + (self.page_row_max - 1)
        self.top_row = row - (self.page_row_max - 1)
      end
      cursor_width = self.width / @column_max - 32
      cursor_width =  32
      x = @index % @column_max * (cursor_width)
      y = @index / @column_max * 32 - self.oy
      self.cursor_rect.set(x, y, cursor_width, 32)
    end
    #--------------------------------------------------------------------------
    # * Get Item
    #--------------------------------------------------------------------------
    def item
      @data ||= []
      return nil if @data[self.index] == nil
      return @data[self.index].item
    end
    #--------------------------------------------------------------------------
    # * Refresh
    #--------------------------------------------------------------------------
    def refresh
      return if @inventory == nil
      if self.contents != nil
        self.contents.dispose
        self.contents = nil
      end
      @data,@text,@align  = [], nil, nil
      @inventory.slots.each {|slot| @data.push(slot) if slot.item != nil }
      @data = @data.sort {|a,b| a.item_id <=> b.item_id }
      @item_max = @data.size
      if @data.size > 0
        self.contents = Bitmap.new(width - 32, row_max * 32)
        @data.each_index {|i|   draw_item(i)}
      end
    end
    #--------------------------------------------------------------------------
    # * Draw Item
    #     index : item number
    #--------------------------------------------------------------------------
    def draw_item(index)
      @data ||= []
      return if @inventory == nil || @data[index] == nil
      item, number = @data[index].item, @data[index].amount
      if item.is_a?(RPG::Item) && $game_party.item_can_use?(item.id)
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      x = index % @column_max * (32) +2
      y = index / @column_max * 32
      s = self.contents.font.size
      rect = Rect.new(x, y, self.width / @column_max - 32, 32)
      self.contents.font.size = 18
      self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
      opacity = self.contents.font.color == normal_color ? 255 : 128
      unless VX
        bitmap = RPG::Cache.icon(item.icon_name) rescue RPG::Cache.icon('')
        self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      else
        draw_icon(item.icon_index, x, y, opacity == 255)
      end
      if item.is_a?(RPG::Item) && number > 1
        a = "/#{$game_party.stack_item(item.id)}" if LiTTleDRAgo::SHOW_ITEM_STACK
        self.contents.font.size = 16
        self.contents.draw_text(x + 2-5, y + 9+1, 32, 32, "#{number}#{a}", 2)
       end
       self.contents.font.size = s
    end
    #--------------------------------------------------------------------------
    # * Set Text
    #--------------------------------------------------------------------------
    def set_text(text, align = 0)
      if text != @text or align != @align
        self.contents.clear
        self.contents.font.color = normal_color
        #draw_colored_words(4, 0, self.width - 40, 32, text)
        self.contents.draw_text(4, 0, self.width - 40, 32, text, align)
        @text,@align = text, align
      end
    end
    #--------------------------------------------------------------------------
    # * Draw Colored Words
    #--------------------------------------------------------------------------
    def draw_colored_words(x,y,width,height,message='',align=0)
      xx = [0, self.contents.font.color.dup]
      t = message.clone
      t.gsub!(/ : /) { "\c[0] : " }
      t.gsub!(/\\[Cc]\[([0-9]+)\]/) { "\001[#{$1}]" }
      while ((c = t.slice!(/./m)) != nil)
        if c == "\001"
          t.sub!(/\[([0-9]+)\]/, "")
          self.contents.font.color = text_color($1.to_i)
          next
        end
        self.contents.draw_text(x + xx[0], y, width, height, c)
        xx[0] += self.contents.text_size(c).width
      end
      self.contents.font.color = xx[1]
    end
    #------------------------------------------------------------------------
    # * Update Help Text
    #------------------------------------------------------------------------
    def update_help
      i = @help_window.is_a?(Window_Welcome) ?
      @help_window.set_text(self.item.nil? ? '' :
        "#{self.item.true_name} : #{self.item.description}",0,self.item) :
      @help_window.set_text(self.item.nil? ? '' :
        "#{self.item.name} : #{self.item.description}")
    end
  end
  #==============================================================================
  # ** Window Item Count
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  #  Class for title of the inventory
  #==============================================================================
  class Window_Item_Count < Window_Base
    #--------------------------------------------------------------------------
    # * Object Initialization
    #    inventory >> an Game_LimitedInventory object
    #--------------------------------------------------------------------------
    def initialize(inventory)
      super(0, 64+15, 320, 64)
      @inventory = inventory
      self.x = 320 if inventory == $game_temp.slots_to_discard
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = "Sylfaen"
      refresh
    end
    #--------------------------------------------------------------------------
    # * Refresh
    #--------------------------------------------------------------------------
    def refresh
      self.contents.clear
      width = self.contents.width
      actor = $game_actors[$game_party.inventory].name rescue ''
      text = sprintf(LiTTleDRAgo::PARTY_INV,actor)
      if @inventory == $game_party.limit_inventory
        self.contents.draw_text(0,0,width,32,text)
        self.contents.draw_text(0,0,width,32,@inventory.slots.size.to_s + " / " + @inventory.max_size.to_s,2)
      else
        self.contents.draw_text(0,0,width,32,LiTTleDRAgo::LOOT_INV)
      end
    end
  end

  class Window_Eq_Show < Window_Base
    def initialize(actor=nil)
      super(0, 152, 200, 176)
      @actor = actor
      self.contents = Bitmap.new(width - 32, height - 32)
      return if actor.nil?
      refresh
    end
    def refresh(s=nil)
      @actor = s if !s.nil?
      @arm = [] if @arm.nil?
      if !@actor.nil? && (@actor != @old_act ||
        @actor.weapon_id != @arm[0] ||
        @actor.armor1_id != @arm[1] ||
        @actor.armor2_id != @arm[2] ||
        @actor.armor3_id != @arm[3] ||
        @actor.armor4_id != @arm[4])
        @old_act = @actor
        @arm = [@actor.weapon_id, @actor.armor1_id, @actor.armor2_id,
                @actor.armor3_id, @actor.armor4_id]
        self.contents.clear
        self.contents.font.color = system_color
        draw_item_name($data_weapons[@arm[0]], 0 , 0)
        draw_item_name($data_armors[@arm[1]], 0 , 28*1)
        draw_item_name($data_armors[@arm[2]], 0 , 28*2)
        draw_item_name($data_armors[@arm[3]], 0 , 28*3)
        draw_item_name($data_armors[@arm[4]], 0 , 28*4)
      end
    end
  end

  #==============================================================================
  # ** Scene_Item
  #------------------------------------------------------------------------------
  #  This class performs item screen processing.
  #==============================================================================

  class Scene_Item
    @@z = 2000
    #--------------------------------------------------------------------------
    # * Initialize
    #--------------------------------------------------------------------------
    def initialize(inv=$game_party.inventory)
      $game_temp.inventory = $game_party.inventory
      $game_party.switch_inventory(inv)
    end
    #--------------------------------------------------------------------------
    # * Main Processing
    #--------------------------------------------------------------------------
    def main
      @sta_window = {}
      @sta_window['help'] = Window_Help.new
      @sta_window['help'].z = @@z
      @sta_window['help'].x = 999
      @item_window = [  Window_Item_Fake_Grid.new,
                        Window_Item_Fake_Grid.new]
      @item_window.each {|i| i.help_window = @sta_window['help'] }
      @item_window[2] = Window_Item_Fake_Grid.new(nil)
      create_inv_com_window
      create_input_number
      @all_window = [ @sta_window['stat']   = Window_Welcome.new('statistic'),
                      @sta_window['well']   = Window_Welcome.new,
                      @sta_window['target'] = Window_Target_Drago.new,
                      @sta_window['eq']     = Window_Eq_Show.new,
                      @inpnum_window, @sta_window['help'], @item_window, @invcom_window]
      @sta_window['stat'].x = 999
      @sta_window['eq'].active =
      @sta_window['target'].active =
      @sta_window['target'].visible =
      @item_window[1].active =
      @item_window[1].visible = false
      @item_window.each {|i| i.z += @@z }
      @item_window[2].z = @item_window[0].z - 10
      @sta_window['target'].z = @item_window[0].z + 50
      @sta_window['eq'].x = -200
      @sta_window['eq'].z = @item_window[0].z + 100
      @sta_window['well'].refresh
      @sta_window['stat'].y -= 40
      @sta_window['stat'].z = @@z - 1
      @sta_window['well'].y = 405
      @sta_window['well'].x = -200
      @sta_window['well'].z = @sta_window['stat'].z + 2
      unless $drg_inv_sys_no_layout
        @sta_window['well'].opacity = 0
        @sta_window['well'].contents_opacity = 0
      end
      Graphics.transition(LiTTleDRAgo::TRAN_TIME, 'Graphics/Transitions/' +
            LiTTleDRAgo::TRAN_TYPE) rescue Graphics.transition
      while $scene == self
        [Graphics,Input].each {|i| i.update}
        update
      end
      30.times {    @sta_window['well'].x += 20
                    @sta_window['help'].x += 20
                    @item_window.each {|i| i.x += 20 }
                    @sta_window['eq'].x -= 20
                    @sta_window['stat'].x += 15
                    Graphics.update
                    @item_lay.opacity -= 15
                    @item_lay.zoom_x += 0.2
                    @sta_window['help'].contents_opacity -= 15     }
      Graphics.freeze
      @all_window.each {|i| i.dispose rescue nil }
      exit_normalize_inventory
      return unless !$game_temp.slots_to_discard.slots.empty? &&
                                 !$scene.is_a?(Scene_Gameover)
      $scene = Scene_Loot.new($game_party.inventory)
    end
    #--------------------------------------------------------------------------
    # * create_input_number
    #--------------------------------------------------------------------------
    def create_input_number
      @inpnum_window = [ Window_InputNumber.new(4),
                         Window_Item_Fake_Grid.new('6')]
      @inpnum_window.each {|i| i.x = 258
                               i.y = 150
                               i.z = @@z + 300 + 50
                               i.visible = i.active = false}
      @inpnum_window[0].y += 32
      @inpnum_window[0].x += 12
      @inpnum_window[1].set_text(LiTTleDRAgo::ASK_MANY,1)
    end
    #--------------------------------------------------------------------------
    # * exit_normalize_inventory
    #--------------------------------------------------------------------------
    def exit_normalize_inventory
      Graphics.resize_screen($game_temp_screen[0],$game_temp_screen[1]) if VX
      return if $game_temp.inventory.nil?
      return unless $game_temp.inventory != $game_party.inventory
      $game_party.switch_inventory($game_temp.inventory)
    end
    #--------------------------------------------------------------------------
    # * create_inv_com_window
    #--------------------------------------------------------------------------
    def create_inv_com_window
      comb = combine_not_exist? ? '' : LiTTleDRAgo::COMBINE_COM
      equ  = equip_not_exist?   ? '' : LiTTleDRAgo::EQ_COM
      del  = [LiTTleDRAgo::DIS_COM, LiTTleDRAgo::CANCEL_COM]
      use  = LiTTleDRAgo::USE_COM
      nocb = combine_not_exist? ||  $game_party.disable_combine
      noeq = equip_not_exist? || $game_party.disable_equip
      tra  = transfer_com
      command_item = tra != '' && !bypass_one_actor?(1) ?
                (nocb ? [use,tra,del[0],del[1]] : [use,tra,comb,del[0]]) :
                (nocb ? [use,del].flatten       : [use, comb, del[0]] )
      command_weap = tra != '' && !bypass_one_actor?(1)  ?
                (nocb ? noeq ? [del[0],tra,del[1]] : [equ,tra,del[0]] :
                 noeq ? [comb,tra,del[0],del[1]] : [comb,tra,equ,del[0]]) :
                (nocb ? noeq ? [del].flatten : [equ,del[0]] :
                 noeq ? [comb,del[0],del[1]] : [comb,equ,del[0]])
      @invcom_window = [Window_Command.new(160, command_item),
                        Window_Command.new(160, command_weap),
                        Window_Command.new(160,[comb,del[1]]),
                        Window_Command.new(190,['',''])]
      @invcom_window.each_with_index {|i,s|  i.x = s == 3 ? 228 : 258
                                i.y = 160 + 1*32
                                i.z = @@z + @item_window[0].z + 200
                                i.active = i.visible = false }
    end
    #--------------------------------------------------------------------------
    # * Frame Update
    #--------------------------------------------------------------------------
    def update
      return update_scene_loot if $scene.is_a?(Scene_Loot)
      @sta_window['well'].update
      @sta_window['help'].update
      @item_window[0].update
      @sta_window['stat'].x = [@sta_window['stat'].x - 10,352].max
      @sta_window['well'].x = [@sta_window['well'].x+10,0].min
      welcome_opac = @sta_window['well'].contents_opacity
      @sta_window['well'].contents_opacity = [welcome_opac+15,255].max
      if @equip_window_active
        @sta_window['eq'].active = true
        @actor = $game_party.actors[@sta_window['target'].index]
        @sta_window['eq'].refresh(@actor)
        @sta_window['eq'].x = [@sta_window['eq'].x+10,0].min
      else
        if @sta_window['eq'].x > -200
          @actor = $game_party.actors[@sta_window['target'].index]
          @sta_window['eq'].refresh(@actor)
          @sta_window['eq'].x -= 10
        elsif @sta_window['eq'].x <= -200
          @sta_window['eq'].active = false
        end
      end
      if @item_window[0].active
        update_item
        update_stats
        if VX
          @sta_window['stat'].x += 1
          @sta_window['stat'].x -= 1
        end
        @sta_window['stat'].visible = @item != nil
        return
      end
      if @invcom_window[0].active || @invcom_window[1].active ||
        @invcom_window[3].active || @inpnum_window[0].active
        @invcom_window.each {|i| i.update if i.active }
        check_max_input
        return update_command
      end
      if @sta_window['target'].active
        @sta_window['target'].update
        return update_target
      end
      if @item_window[1].active
        @item_window[1].update
        update_stats
        update_combine
        return
      end
      if @invcom_window[2].active
        @invcom_window[2].update
        return update_command
      end
    end
    #--------------------------------------------------------------------------
    # * check_max_input
    #--------------------------------------------------------------------------
    def check_max_input
      @inpnum_window[0].update if @inpnum_window[0].active
      return unless @inpnum_window[0].number > (@number_item || 0)
      @inpnum_window[0].number, @number_overload = !@number_overload ?
            [@number_item, true] : [0 , false]
    end
    #--------------------------------------------------------------------------
    # * Update Command Window
    #--------------------------------------------------------------------------
    def update_command
      if Input.trigger?(Input::B)
        return cancel_combination
      end
      if Input.trigger?(Input::C)
        if @item.is_a?(RPG::Item) && @invcom_window[0].active &&
          !@invcom_window[2].active && !@invcom_window[3].active
          nocomb = combine_not_exist? || $game_party.disable_combine
          if @invcom_window[1].commands.size != 4
            case @invcom_window[0].index
            when 0 then use_item
            when 1 then nocomb ? discard_item : combine_item
            when 2 then nocomb ? cancel_combination : discard_item
            end
          else
            case @invcom_window[0].index
            when 0 then use_item
            when 1 then transfer_item
            when 2 then nocomb ? discard_item : combine_item
            when 3 then nocomb ? cancel_combination : discard_item
            end
          end
        elsif (@item.is_a?(RPG::Weapon) || @item.is_a?(RPG::Armor)) &&
          @invcom_window[1].active && !@invcom_window[3].active
          noeq = equip_not_exist? || $game_party.disable_equip
          nocomb = 0
          nocomb += 1 if @invcom_window[1].commands.size == 2
          if @invcom_window[1].commands.size != 4
            case @invcom_window[1].index + nocomb
            when 0 then combine_item
            when 1 then noeq ? discard_item : equip_item
            when 2 then noeq ? cancel_combination : discard_item
            end
          else
            case @invcom_window[1].index + nocomb
            when 0 then combine_item
            when 1 then transfer_item
            when 2 then noeq ? discard_item : equip_item
            when 3 then noeq ? cancel_combination : discard_item
            end
          end
        elsif @invcom_window[2].active && !@invcom_window[0].active
          case @invcom_window[2].index
          when 0 then combination
          when 1 then cancel_combination
          end
        elsif @invcom_window[3].active
          case @invcom_window[3].index
          when 0 then update_unequip(0)
          when 1 then update_unequip(1)
          when 2 then cancel_combination
          end
        elsif @inpnum_window[0].active
          discard_item_value  if @number_purpose == 'Discard'
          transfer_item_value if @number_purpose == 'Transfer'
        end
        @invcom_window.each {|i| i.index = 0 }
        return
      end
    end
    #--------------------------------------------------------------------------
    # * combine_not_exist?
    #--------------------------------------------------------------------------
    def combine_not_exist?
      mtd = [LiTTleDRAgo::COMBINE_ITEM,LiTTleDRAgo::COMBINE_COM] rescue []
      result = mtd[0].nil? || mtd[0] == {} || mtd[0] == [] ||
              mtd[1].nil? || mtd[1] == ''
      return result
    end
    #--------------------------------------------------------------------------
    # * transfer_com
    #--------------------------------------------------------------------------
    def transfer_com()  LiTTleDRAgo::TRANSFER_COM || '' rescue ''  end
    #--------------------------------------------------------------------------
    # * equip_not_exist?
    #--------------------------------------------------------------------------
    def equip_not_exist?
      result = LiTTleDRAgo::EQ_COM.nil? ||
               LiTTleDRAgo::EQ_COM == '' rescue true
      return result
    end
    #--------------------------------------------------------------------------
    # * cancel_combination
    #--------------------------------------------------------------------------
    def cancel_combination
      sound_play('cancel')
      discard_item_value(0) if @inpnum_window[0].active
      @item_window[0].active  = true  unless @inpnum_window[0].active
      @item_window[0].visible = true  unless @inpnum_window[0].active
      @item_window[1].active  = false unless @inpnum_window[0].active
      @item_window[1].visible = false unless @inpnum_window[0].active
      @invcom_window.each {|i|  i.active = i.visible = false }
      @inpnum_window.each {|i|  i.active = i.visible = false }
      @equip_window_active = @number_overload = nil
      @sta_window['well'].refresh
      @number_item = 0
      return
    end
    #--------------------------------------------------------------------------
    # * Use Item Processing
    #--------------------------------------------------------------------------
    def equip_item
      @sta_window['eq'].refresh(@actor) if !@sta_window['eq'].nil?
      return sound_play('buzzer') if @item.is_a?(RPG::Item)
      sound_play('decision')
      @invcom_window.each {|i|  i.active = i.visible = false }
      @sta_window['target'].active  =
      @sta_window['target'].visible =
      @equip_window_active = true
      @sta_window['target'].index = 0
      @sta_window['well'].set_text(LiTTleDRAgo::EQUIP_WELCOME)
    end
    #--------------------------------------------------------------------------
    # * transfer_item_update
    #--------------------------------------------------------------------------
    def transfer_item_update
      @transfer_flag = false
      slot = @item_window[0].inventory.slot(@item) rescue nil
      return sound_play('buzzer') if slot.nil?
      type, id, @number_item = slot.item_type, slot.item_id, slot.amount
      return sound_play('buzzer') if LiTTleDRAgo::NONDISCARD[type].include?(id)
      sound_play('decision')
      @invcom_window.each {|i| i.active = i.visible = false }
      @inpnum_window.each {|i| i.active = i.visible = true  }
      @inpnum_window[0].number = 0
      @number_purpose = 'Transfer'
    end
    #--------------------------------------------------------------------------
    # * transfer_item_value
    #--------------------------------------------------------------------------
    def transfer_item_value
      @transfer_flag = false
      @actor = $game_party.actors[@sta_window['target'].index]
      sound_play('decision')
      inv, n = $game_party.inventory, @inpnum_window[0].number
      n.times { $game_party.transfer_process(@item,1,inv,@actor.id) }
      @item_window.each {|i| i.refresh }
      @inpnum_window.each {|i| i.active = i.visible = false }
      @item_window[0].active = true
      @sta_window['target'].active  =
      @sta_window['target'].visible = false
      @item_window[0].index = [[@item_window[0].index,0].max,
                                @item_window[0].item_max-1].min
      @sta_window['well'].refresh
      @must_update = true
    end
    #--------------------------------------------------------------------------
    # * Discard Item Processing
    #--------------------------------------------------------------------------
    def discard_item
      slot = @item_window[0].inventory.slot_reverse(@item) rescue nil
      return if slot.nil?
      type, id, @number_item = slot.item_type, slot.item_id, item_number(@item)
      return sound_play('buzzer') if LiTTleDRAgo::NONDISCARD[type].include?(id)
      sound_play('decision')
      @invcom_window.each {|i| i.active = i.visible = false }
      @inpnum_window.each {|i| i.active = i.visible = true  }
      @inpnum_window[0].number = 0
      @number_purpose = 'Discard'
    end
    #--------------------------------------------------------------------------
    # * discard_item_value
    #--------------------------------------------------------------------------
    def discard_item_value(number = @inpnum_window[0].number)
      slot = @item_window[0].inventory.slot_reverse(@item) rescue nil
      return if slot.nil?
      type, id, n = slot.item_type, slot.item_id, number
      return sound_play('buzzer') if LiTTleDRAgo::NONDISCARD[type].include?(id)
      sound_play(number > 0 ? 'decision' : 'cancel')
      $game_party.no_multi_use = true
      n.times {  $game_party.lose_item(@item, 1) if item_number(@item) > 0  }
      @sta_window['well'].refresh
      @item_window.each {|i| i.refresh }
      @inpnum_window.each {|i| i.active = i.visible = false }
      @item_window[0].active = true
      @item_window[0].index = [[@item_window[0].index-1,0].max,
                                @item_window[0].item_max-1].min
      $game_party.no_multi_use = false
      @equip_window_active = false
      @must_update = true
    end
    #--------------------------------------------------------------------------
    # * Transfer Item Processing
    #--------------------------------------------------------------------------
    def transfer_item
      sound_play('decision')
      @invcom_window.each {|i|  i.active = i.visible = false }
      @sta_window['target'].active  =
      @sta_window['target'].visible = true
      @equip_window_active = false
      @sta_window['target'].index = 0
      @transfer_flag = true
    end
    #--------------------------------------------------------------------------
    # * Use Item Processing
    #--------------------------------------------------------------------------
    def use_item
      unless @item.is_a?(RPG::Item) || $game_party.item_can_use?(@item.id)
        return sound_play('buzzer')
      end
      if $xrxs_xas
        if XAS::XASITEM_ID[@item.id] != nil && $game_player.can_action?
          sound_play('decision')
          $game_system.xas_item_id = @item.id
          $scene = Scene_Map.new
          $game_player.active_item
        end
        return
      end
      sound_play('decision') unless bypass_one_actor?
      if @item.scope >= 3
        @invcom_window.each {|i|  i.active = i.visible = false }
        @sta_window['target'].active  = true
        @sta_window['target'].visible = bypass_one_actor? ? false : true
        @equip_window_active = false
        if @item.scope == 4 || @item.scope == 6
          @sta_window['target'].index = -1
        else
          @sta_window['target'].index = 0
        end
      else
        if @item.common_event_id > 0
          $game_temp.common_event_id = @item.common_event_id
          sound_play('use_item')
          if @item.consumable
            @sta_window['well'].refresh
            $game_party.lose_item(@item.id, 1)
            @item_window[0].draw_item(@item_window[0].index)
          end
          return $scene = Scene_Map.new
        end
      end
    end
    #--------------------------------------------------------------------------
    # * Use Item Processing
    #--------------------------------------------------------------------------
    def combine_item
      sound_play('decision')
      @invcom_window.each {|i| i.active = i.visible = false }
      @invcom_window[2].active  = true
      @invcom_window[2].visible = false
      @item_window.each_with_index {|i,s|
                i.active = i.visible = s == 0 ? false : true }
      @equip_window_active = false
      @item_window[1].index = 0
    end
    #--------------------------------------------------------------------------
    # * Frame Update (combine item window is active)
    #--------------------------------------------------------------------------
    def update_combine
      if Input.trigger?(Input::B)
        sound_play('cancel')
        return $scene = Scene_Menu.new(0)
      end
      if Input.trigger?(Input::C)
        @item_1 = @item_window[0].item
        @item_2 = @item_window[1].item
        if @item_1 != nil && @item_2 != nil
          c = combine_result rescue nil
          c.nil? ? @invcom_window[2].disable_item(0) : @invcom_window[2].refresh
          @invcom_window.each {|i| i.active = i.visible = false }
          @invcom_window[2].active  =
          @invcom_window[2].visible = true
          @item_window[1].active =
          @equip_window_active = false
          @number_item = 0
        else
          sound_play('buzzer')
        end
        return
      end
    end
    #--------------------------------------------------------------------------
    # * Frame Update (when item window is active)
    #--------------------------------------------------------------------------
    def update_item
      if Input.trigger?(Input::B)
        sound_play('cancel')
        return $scene = Scene_Menu.new(0)
      end
      if Input.trigger?(Input::C)
        @item = @item_window[0].item
        if @item != nil
          sound_play('decision')
          if @item.is_a?(RPG::Item)
            @invcom_window.each {|i| i.active = i.visible = false }
            @invcom_window[0].active  =
            @invcom_window[0].visible = true
            @item_window[0].active = false
          elsif @item.is_a?(RPG::Weapon) || @item.is_a?(RPG::Armor)
            @invcom_window.each {|i| i.active = i.visible = false }
            @invcom_window[1].active  =
            @invcom_window[1].visible = true
            @item_window[0].active =
            @equip_window_active      = false
          end
        else
          sound_play('buzzer')
        end
        return
      end
    end
    #--------------------------------------------------------------------------
    # * update_unequip
    #--------------------------------------------------------------------------
    def update_unequip(type=0,siz=$game_party.limit_inventory.slots.size >=
                       $game_party.limit_inventory.max_size)
      if type == 0
        if @item.is_a?(RPG::Weapon) && !@actor.equip_fix?(0) && !siz
          @actor.equip(0, 0)
          sound_play('equip')
        elsif @item.is_a?(RPG::Armor)&& !@actor.equip_fix?(@item.kind+1) && !siz
          @actor.equip(@item.kind+1, 0)
          sound_play('equip')
        else
          sound_play('buzzer')
          @sta_window['well'].set_text(LiTTleDRAgo::FULL_INVENTORY) if siz
        end
      else
        @play_unequip = []
        (0...4).each {|i| @play_unequip[1] =
                             ($game_party.limit_inventory.slots.size >=
                              $game_party.limit_inventory.max_size)
                          unless @actor.equip_fix?(i) || @play_unequip[1]
                            @actor.equip(i, 0)
                            @play_unequip[0] = true
                          end}
        @play_unequip[0] ? sound_play('equip') : sound_play('buzzer')
        @sta_window['well'].set_text(LiTTleDRAgo::FULL_INVENTORY) if @play_unequip[1]
      end
      @item_window.each {|i| i.refresh }
      @invcom_window[3].active  =
      @invcom_window[3].visible = false
      @sta_window['target'].visible =
      @sta_window['target'].active  = true
    end
    #--------------------------------------------------------------------------
    # * cancel_target
    #--------------------------------------------------------------------------
    def cancel_target
      @item_window.each {|i| i.refresh }
      @item_window[0].active = true
      @sta_window['target'].visible =
      @sta_window['target'].active  = false
      @sta_window['well'].refresh
      @equip_window_active = nil
    end
    #--------------------------------------------------------------------------
    # * update_target
    #--------------------------------------------------------------------------
    def update_target
      if Input.trigger?(Input::B)
        sound_play('cancel')
        return cancel_target
      end
      if @transfer_flag
        transfer_item_update if Input.trigger?(Input::C)
        return
      end
      if Input.trigger?(Input::A)
        @actor = $game_party.actors[@sta_window['target'].index]
        if @item.is_a?(RPG::Weapon) || @item.is_a?(RPG::Armor)
          sound_play('decision')
          del = [LiTTleDRAgo::UNEQUIP_COM, LiTTleDRAgo::UNEQUIPALL_COM,
                LiTTleDRAgo::CANCEL_COM]
          items = case @item
          when RPG::Weapon then 'Weapon'
          when RPG::Armor then VX ? eval("Vocab.armor#{@item.kind + 1}") :
                               $data_system.words.send("armor#{@item.kind + 1}")
          end
          @invcom_window[3].commands = ["#{del[0]} #{items}" ,del[1], del[2]]
          @invcom_window[3].refresh
          @invcom_window[3].active  =
          @invcom_window[3].visible = true
          @sta_window['target'].visible =
          @sta_window['target'].active  = false
          return @must_update = true
        end
      end
      if Input.trigger?(Input::C) || bypass_one_actor?
        @actor = $game_party.actors[@sta_window['target'].index]
        if @item.is_a?(RPG::Weapon) || @item.is_a?(RPG::Armor)
          if !@actor.equippable?(@item) ||
           (@item.is_a?(RPG::Weapon) && @actor.equip_fix?(0)) ||
           (@item.is_a?(RPG::Armor) && @actor.equip_fix?(@item.kind+1))
            cancel_target if bypass_one_actor?
            return sound_play('buzzer')
          end
          sound_play('equip')
          if @item.is_a?(RPG::Weapon)
            @actor.equip(0, @item.nil? ? 0 : @item.id)
          elsif @item.is_a?(RPG::Armor)
            @actor.equip(@item.kind+1, @item.nil? ? 0 : @item.id)
          end
          @sta_window['eq'].refresh(@actor)
          @item_window[0].refresh
          return @must_update = true
        end
        return sound_play('buzzer') if $game_party.item_number(@item.id) == 0
        if @sta_window['target'].index == -1
          used = false
          for i in $game_party.actors
            used |= i.item_effect(@item)
          end
        end
        if @sta_window['target'].index >= 0
          target = $game_party.actors[@sta_window['target'].index]
          used = target.item_effect(@item)
        end
        if used
          sound_play('use_item')
          if @item.consumable
            $game_party.lose_item(@item.id, 1)
            @item_window[0].draw_item(@item_window[0].index)
            @item_window[0].refresh
            @sta_window['well'].refresh
          end
          @sta_window['target'].refresh
          return $scene = Scene_Gameover.new if $game_party.all_dead?
          if @item.common_event_id > 0
            $game_temp.common_event_id = @item.common_event_id
            return $scene = Scene_Map.new
          end
        end
        cancel_target if bypass_one_actor?
        sound_play('buzzer') unless used
        return
      end
    end
    #--------------------------------------------------------------------------
    # * Bypass one actor
    #--------------------------------------------------------------------------
    def bypass_one_actor?(type=0)
      return true if $game_party.actors.size == 1 && type == 1
      return true if $game_party.actors.size == 1 &&
                     @item.is_a?(RPG::Item) && type == 0
    end
    #--------------------------------------------------------------------------
    # * Combine Result
    #--------------------------------------------------------------------------
    def combine_result
      req, com = [], LiTTleDRAgo::COMBINE_ITEM
      req[0] = case @item_1
      when RPG::Item then 'Item(' + @item_1.id.to_s + ')'
      when RPG::Weapon then 'Weapon(' + @item_1.id.to_s + ')'
      when RPG::Armor then 'Armor(' + @item_1.id.to_s + ')'
      end
      req[1] = case @item_2
      when RPG::Item then 'Item(' + @item_2.id.to_s + ')'
      when RPG::Weapon then 'Weapon(' + @item_2.id.to_s + ')'
      when RPG::Armor then 'Armor(' + @item_2.id.to_s + ')'
      end
      req[3] = com[req[0] + ' + ' + req[1]] rescue nil
      req[3] = req[3] ? req[3] : com[req[1] + ' + ' + req[0]] rescue ''
      if req[3] =~ /item/i
        item = req[3].downcase.gsub(/item\(([0-9]+)\)/) { $1 }
        item = $data_items[item.to_i]
      elsif req[3] =~ /weapon/i
        item = req[3].downcase.gsub(/weapon\(([0-9]+)\)/) { $1 }
        item = $data_weapons[item.to_i]
      elsif req[3] =~ /armor/i
        item = req[3].downcase.gsub(/armor\(([0-9]+)\)/) { $1 }
        item = $data_armors[item.to_i]
      end
      return item
    end
    #--------------------------------------------------------------------------
    # * Item Number
    #--------------------------------------------------------------------------
    def item_number(item)
      case item
      when RPG::Item   then $game_party.item_number(item.id)
      when RPG::Weapon then $game_party.weapon_number(item.id)
      when RPG::Armor  then $game_party.armor_number(item.id)
      end
    end
    #--------------------------------------------------------------------------
    # * Combination
    #--------------------------------------------------------------------------
    def combination
      c = combine_result rescue nil
      number = [item_number(@item_1), item_number(@item_2)]
      if c != nil && ((@item_1 != @item_2 && number[0] > 0 && number[1] > 0) ||
        (@item_1 == @item_2 && number[0] > 1))
        number[2],text = item_number(c),LiTTleDRAgo::GET_COMB
        stack = c.is_a?(RPG::Item) ? $game_party.stack_item(c.id) : 1
        if slot.size>=limit_max && (number[2] <= 0 || (number[2]%stack) == 0) &&
          ((@item_1 != @item_2 && number[0] > 1 && number[1] > 1) ||
          (@item_1 == @item_2 && number[0] > 2))
          @sta_window['well'].refresh(LiTTleDRAgo::FULL_INVENTORY)
          return sound_play('buzzer')
        end
        $game_party.lose_item(@item_1,1)
        $game_party.lose_item(@item_2,1)
        $game_party.gain_item(c,1)
        @item_window.each {|i| i.refresh }
        @number_item = (@number_item || 0) + 1
        @sta_window['well'].set_text(sprintf(text, c.name,@number_item))
        cancel_combination if item_number(@item_1) <= 0||item_number(@item_2) <= 0
        @must_update = true
        sound = LiTTleDRAgo::SOUND_COMBINE rescue ''
        return Audio.se_play("Audio/SE/#{sound}", 80, 100) rescue nil
      else
        return sound_play('buzzer')
      end
    end

    def slot()            $game_party.limit_inventory.slots    end
    def limit_max()       $game_party.limit_inventory.max_size end
    #--------------------------------------------------------------------------
    # Sound Play
    #--------------------------------------------------------------------------
    def sound_play(se)
      case se
      when 'cursor'
        VX ? Sound.play_cursor : $game_system.se_play($data_system.cursor_se)
      when 'cancel'
        VX ? Sound.play_cancel : $game_system.se_play($data_system.cancel_se)
      when 'equip'
        VX ? Sound.play_equip : $game_system.se_play($data_system.equip_se)
      when 'use_item'
        VX ? Sound.play_use_item : $game_system.se_play(@item.menu_se)
      when 'decision'
        VX ? VXA ? Sound.play_ok : Sound.play_decision :
        $game_system.se_play($data_system.decision_se)
      when 'buzzer'
        VX ? Sound.play_buzzer : $game_system.se_play($data_system.buzzer_se)
      end
    end
    #--------------------------------------------------------------------------
    # * report_no_star
    #--------------------------------------------------------------------------
    def report_missing_image(image,loc)
      return unless $DEBUG || $TEST
      bit = Bitmap.new(480, 72)
      bit.font.size = 16
      bit.font.bold = true
      bit.draw_text(4,52,472,24,
                "Image #{image} can\'t be found at folder #{loc}.", 1)
      Graphics.freeze
      $spr = Sprite.new
      $spr.bitmap = bit
      $spr.x, $spr.y = 320-(472/2), 240-(72/2)
      $spr.z = 1000
      Graphics.transition
      3600.times  {  [Graphics,Input].each {|i| i.update }
                      break if Input.trigger?(Input::C)  }
      Graphics.freeze
      $spr.bitmap.dispose
      $spr.dispose
      Graphics.transition
    end
    #--------------------------------------------------------------------------
    # * Create Layout
    #--------------------------------------------------------------------------
    def create_layout
      $game_temp_screen = [Graphics.width,Graphics.height] if VX
      Graphics.resize_screen(640,480) if VX
      @item_lay, @btm = Sprite.new,'Item_Lay'
      @map_back = VX ? Spriteset_Map_Drago.new : Spriteset_Map.new
      @mnback = Plane.new
      cache = VX ? Cache : RPG::Cache
      unless $drg_inv_sys_no_layout || @btm == ''
        image = cache.picture(@btm) rescue ''
        if image == ''
          report_missing_image(@btm.to_s,'Pictures')
          $drg_inv_sys_no_layout,@btm = true,''
        end
      else
        @btm = ''
      end
      @item_lay.bitmap = cache.picture(@btm)
      @item_lay.z = @@z
      @btm = LiTTleDRAgo::BACKGROUND
      unless $drg_inv_sys_no_background || @btm == ''
        image = cache.picture(@btm) rescue cache.windowskin(@btm) rescue ''
        if image == ''
          report_missing_image(@btm.to_s,'Pictures')
          $drg_inv_sys_no_background,@btm = true,''
        end
      else
        @btm = ''
      end
      @mnback.bitmap = cache.picture(@btm) rescue cache.windowskin(@btm) rescue ''
      @mnback.z = @@z-1
      @mnback.opacity = 155
      @mnback.blend_type = 0
    end
    #--------------------------------------------------------------------------
    # Update Layout
    #--------------------------------------------------------------------------
    def update_layout
      unless @all_window.include?(@mnback)
        @all_window << [@mnback,@item_lay,@map_back]
        @all_window.flatten!
      end
      @mnback.visible = true
      @mnback.ox += 1
      @mnback.oy += 1
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Aliased Method
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    alias drg112_main main  unless method_defined?(:drg112_main)
    alias drg112_upd update unless method_defined?(:drg112_upd)
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Main Processing
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def main
      create_layout
      drg112_main
    end
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    # * Frame Update
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def update
      update_layout
      drg112_upd
    end
  end #of class
  #==============================================================================
  # ** Scene_Loot
  #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  #  Loot management scene
  #==============================================================================
  class Scene_Loot < Scene_Item
    #--------------------------------------------------------------------------
    # * MainProcessing
    #--------------------------------------------------------------------------
    define_method(:refresh){[@all_party,@all_loot].flatten.each {|i| i.refresh}}
    def main
      dis = $game_temp.slots_to_discard
      create_layout
      @all_window = [
        @help_window     = Window_Welcome.new('help'),
        @item_window     = Window_Item_Fake_Grid.new,
        @dummy1_window   = Window_Item_Fake_Grid.new(nil),
        @loot_window     = Window_Item_Fake_Grid.new(dis),
        @dummy2_window   = Window_Item_Fake_Grid.new(dis,nil),
        @party_item_window = Window_Item_Count.new($game_party.limit_inventory),
        @loot_item_window  = Window_Item_Count.new($game_temp.slots_to_discard)]
      @item_window.help_window = @help_window
      @loot_window.help_window = @help_window
      @loot_window.active = false
      @loot_window.x = 320
      @item_window.z = @loot_window.z += @@z + 1
      @dummy2_window.x = @loot_window.x
      create_input_number
      @all_window <<  @inpnum_window
      @all_dummy = [@dummy1_window,@dummy2_window]
      @all_party = [@party_item_window,@item_window,@dummy1_window]
      @all_loot = [@loot_item_window,@loot_window,@dummy2_window]
      @all_atas = [@party_item_window,@loot_item_window]
      if true
        @sprite_qw = Sprite.new
        @sprite_qw.bitmap = Bitmap.new(640,480)
        @sprite_qw.bitmap.font.name = "Sylfaen"
        @sprite_qw.bitmap.font.size = 50
        @sprite_qw.bitmap.draw_text(0,230,640,72,'  <Q',0)
        @sprite_qw.bitmap.draw_text(0,230,640,72,'W>  ',2)
        @sprite_qw.z = @item_window.z
        @sprite_qw.opacity = 0
        @all_window << @sprite_qw
      end
      @loot_item_window.x = 320
      @help_window.y = 405
      @help_window.x = -200
      @help_window.z = @item_window.z
      @item_window_x = @item_window.x
      @all_atas.each {|i| i.z = @mnback.z + 1
                            i.opacity = 180 }
      @all_party.each {|i| i.x -= 320 }
      @all_loot.each  {|i| i.x += 320 }
      @all_dummy.each {|i| i.z = @item_window.z - 100
                            i.opacity = 180 }
      unless $drg_inv_sys_no_layout
        @help_window.opacity = 0
        @help_window.contents_opacity = 0
      end
      Graphics.transition(LiTTleDRAgo::TRAN_TIME, 'Graphics/Transitions/' +
            LiTTleDRAgo::TRAN_TYPE) rescue Graphics.transition
      while $scene == self
        [Graphics,Input].each {|i| i.update}
        update
      end
      30.times { [Graphics,Input].each {|i| i.update}
                  @sprite_qw.opacity -= 10
                  @sprite_qw.zoom_x += 0.2
                  @sprite_qw.x -= 22
                  @help_window.x += 15
                  @all_party.each {|i| i.x -= 10 }
                  @all_loot.each {|i| i.x += 10 }
                  @item_lay.opacity -= 10
                  @item_lay.zoom_x += 0.2}
      Graphics.freeze
      @all_window.each {|i| i.dispose  rescue nil }
      exit_normalize_inventory
    end
    #--------------------------------------------------------------------------
    # * update animated_position
    #--------------------------------------------------------------------------
    def update_animated_position
      @help_window.x = [@help_window.x+10,0].min
      @help_window.contents_opacity = [@help_window.contents_opacity+15,255].max
      if @party_item_window.x == 0
        @sprite_qw.opacity = [@sprite_qw.opacity+15,255].min
        if @sprite_qw.oy < 50 && !@below
          @sprite_qw.oy += 1
          @below = true if @sprite_qw.oy >= 50
        elsif @sprite_qw.oy > 0 && @below
          @sprite_qw.oy -= 1
          @below = false if @sprite_qw.oy <= 0
        end
      end
      @all_party.each_with_index {|i,s|  i.x = [i.x + 10,
                                  s == 0 ? 0 : @item_window_x].min }
      @all_loot.each_with_index {|i,s| i.x = [i.x - 10,
                          320 + (s == 0 ? 0 : (100-@item_window_x).abs)].max }
    end
    #--------------------------------------------------------------------------
    # * update Frame
    #--------------------------------------------------------------------------
    def update
      update_scene_loot
    end

    def update_scene_loot
      update_animated_position
      update_layout
      if Input.trigger?(Input::B)
        sound_play('cancel')
        if @inpnum_window[0].active
          @inpnum_window.each {|i| i.active = i.visible = false }
          @item_active = @loot_active = false
          return
        end
        if !$game_temp.slots_to_discard.slots.empty?
          $game_temp.slots_to_discard.slots.each { |slot|
            $game_party.reduce_item(slot.item, slot.amount) }
          $game_temp.slots_to_discard.clear
        end
        return  $scene = Scene_Map.new
      end
      if @inpnum_window[0].active
        #@inpnum_window[0].update
        check_max_input
      end
      if @item_window.active
        @item_window.update unless @item_active
        return update_item
      end
      if @loot_window.active
        @loot_window.update unless @loot_active
        return update_loot
      end
    end
    #--------------------------------------------------------------------------
    # * Update Item Window
    #--------------------------------------------------------------------------
    def update_item
      if Input.trigger?(Input::C)
        @inpnum_window[0].active ? item_to_loot_value : item_to_loot
        return
      end
      if Input.repeat?(Input::R)
        @item_window.active = false
        @loot_window.active = true
        @loot_window.index = 0
        @item_window.index = -1
        sound_play('decision')
        return
      end
    end
    #--------------------------------------------------------------------------
    # * Update Loot Window
    #--------------------------------------------------------------------------
    def update_loot
      if Input.trigger?(Input::C)
        @inpnum_window[0].active ? loot_to_item_value : loot_to_item
        return
      end
      if Input.repeat?(Input::L)
        @item_window.active = true
        @loot_window.active = false
        @loot_window.index = -1
        @item_window.index = 0
        sound_play('decision')
        return
      end
    end
    #--------------------------------------------------------------------------
    # * item_to_loot
    #--------------------------------------------------------------------------
    def item_to_loot
      item = @item_window.item
      return if item.nil?
      slot = @item_window.inventory.slot(item)
      type, id, @number_item = slot.item_type, slot.item_id, slot.amount
      return sound_play('buzzer') if LiTTleDRAgo::NONDISCARD[type].include?(item.id)
      sound_play('decision')
      @inpnum_window.each {|i| i.active = i.visible = true }
      @inpnum_window[0].number = @number_item
      @item_active = true
    end
    #--------------------------------------------------------------------------
    # * item_to_loot_value
    #--------------------------------------------------------------------------
    def item_to_loot_value
      item = @item_window.item
      return if item.nil?
      @item_active = false
      slot = @item_window.inventory.slot(item)
      type, id, n = slot.item_type, slot.item_id, @inpnum_window[0].number
      sound_play('decision')
      n.times {  $game_party.limit_inventory.remove_item(type, id, 1)
                 $game_temp.slots_to_discard.add_item(type, id, 1) }
      @inpnum_window.each {|i| i.active = i.visible = false }
      refresh
    end
    #--------------------------------------------------------------------------
    # * loot_to_item
    #--------------------------------------------------------------------------
    def loot_to_item
      item = @loot_window.item
      return if item.nil?
      slot = @loot_window.inventory.slot_reverse(item)
      type, id, @number_item = slot.item_type, slot.item_id, slot.amount
      sound_play('decision')
      @inpnum_window.each {|i| i.active = i.visible = true }
      @inpnum_window[0].number = @number_item
      @loot_active = true
    end
    #--------------------------------------------------------------------------
    # * loot_to_item_value
    #--------------------------------------------------------------------------
    def loot_to_item_value
      item = @loot_window.item
      return if item.nil?
      @loot_active = false
      slot = @loot_window.inventory.slot_reverse(item)
      type, id, n = slot.item_type, slot.item_id, @inpnum_window[0].number
      n.times {
      oth = @item_window.inventory.slots[$game_party.limit_inventory.max_size-1]
      oth = oth.nil? ? 0 : oth.amount
      stack = item.is_a?(RPG::Item) ? $game_party.stack_item(item.id) : 1
      slots = $game_party.limit_inventory.slots
      limit_max = $game_party.limit_inventory.max_size
      unless slots.size >= limit_max && oth >= stack
        sound_play('decision')
        $game_party.limit_inventory.add_item(type, id, 1)
        $game_temp.slots_to_discard.remove_item(type, id, 1)
      else
        sound_play('buzzer')
      end }
      @inpnum_window.each {|i| i.active = i.visible = false }
      refresh
    end
  end
end