FP Inventory System

[KayDgirl91 99]

This script looks amazing! Really excited to test it out! 

[Ewaldar 0]

Hi,

 

I'm using your script, and I have a question : Why when you equip a weapon/armor, the weight decrease ??? It should stay the same, as the person has the Equipment on her.

 

Thanks for the answer

[Mattyp1992 0]

Hello, Great Script. For all those like me who where confused by the weight limit window in the items window. I have found the answer. Instead of removing it you can just alter where it appears and therefore move it out the window completely.

 

The line that needs to be altered is Line 868 Change the X=160 to 1600. The Window then disappears. 

 

 def create_limit_windows

    x = 1600

    if Feature_Plus::Inventory_System::Use_Weight_Limit

      @weight_window = Window_Weight.new(Graphics.width - x, 0)

      @weight_window.z = 200

      @actor_window.z = 300

      x += 160

    end

[MoonEnder 1]

hi thanks for this script i love it!

but i have a question,

how do i set something up that sents the current inventory weight to a variable?

thanks in advance!

 

edit

nevermind i magaged to google around and figure it out

script is still awsome though

Edited December 16, 2013 by cubeking

[MasterChafa 0]

Hi. I know, lots of posts with the same request.
Please do max weight and slots controled by variables!!!
Speaking of slots, what about a function in which an item can ocuppy more than 1 slot?
Thanks

Edited December 23, 2013 by MasterChafa

[MasterChafa 0]

About variable-controled max weight/ items:

This is the modified script i did (based on Lisah's idea, thanks) which controls weight limit with variable 12, and item limit with variable 15 (of course you can change them, but must change every instance of em in the script). For testing it, i created events which raised both variables in-game, and they seemed to work correctly so far; The numbers indicating max weight and items raised in menu along with the variables, also i could put more weight and more items in my inventory if i raised those variables enough, and my inventory wont accept any item if one of the variables room is reached (which is exactly what i wanted).

 

Anyways, even though it worked well in my tests, i wouldnt put it on a serious project until the autor shows up with a reliable modification

=begin
#==============================================================================
 ** FP Inventory Plus
 Author: Tsukihime
 Date: Jul 10, 2012
------------------------------------------------------------------------------
 ** Change log
 Jul 10
   -fixed logic error where == wasn't returning false if no branches return
 Jul 9
   -restructured Game_Weapon, Game_Armor, and Game_Item to include a new
    BaseItem module
   -overwrote == logic to distinguish between RPG objects and custom objects.
 Jun 26
   -added proper item losing
 May 30
   -fixed issue where item type check wasn't checked properly
    eg: default weapon check assumes class == RPG::Weapon
 May 29
   -added counting options: count-by-item, count-by-stack
 May 27
   -added options to enable/disable item/weight limits
   -added item limit window
 May 26
   -added the imported boolean
 May 24
   -Initialized RPG classes
 May 22
   -Added "clear inventory" method to clear everything out
   -Clears out equips as well
 May 15, 2012
   - fixed some bugs
 May 14, 2012
   - Initial release
------------------------------------------------------------------------------    
 This script extends the default inventory system and all item-handling
 throughout the engine. All items will be fetched from the inventory, and
 instances of the specific item is stored and retrieved.
 
 You can specify the stack sizes for each item as well as their weights.
 You can specify item limits and weight limits for each item.
 All equips are treated independently.
 
 This script will act as the basis for all future item-related scripts.
 
 To specify an item/equip stack size, tag it with
 
    <stack: n>
 where n is an integer >= 1
    
 To specify the weight of an item/equip, tag it with
 
    <weight: n>
 where n is a real number
    
 To specify the the limit for an item/equip, tag it with
    <limit: n>
 where n is an integer >= 0
 
#==============================================================================
=end
$imported = {} if $imported.nil?
$imported["FP_InventoryPlus"] = true
#==============================================================================
# ** Configuration
#==============================================================================
module Feature_Plus
  module Inventory_System
    
    Use_Item_Limit = true
    Use_Weight_Limit = true
    
    # Item counting method. If "Count_Items" is true, then
    # Count_Stacks is not used
    
    Count_By_Stack = false # treat each stack as a single item
    Count_By_Item = true  # count every item individually
    
    # Stack defaults
    Default_Item_Stack = 9999
    Default_Equip_Stack = 1
    
    # weight defaults
    Default_KeyItem_Weight = 0
    Default_Item_Weight = 1
    Default_Equip_Weight = 0
    
    Weight_Unit = "Kg"
    
    # [current weight] / [max weight] [weight unit]
    Weight_Display = "%s/%s %s"
    
    # [item_count] / [item_limit]
    Item_Display = "Items: %s/%s"
    
    # Inventory limit defaults
    #Inventory_Limit = 40   #max inventory size
    #Weight_Limit =   40    #max inventory weight
    
    #regex
    Item_Limit = /<limit:?\s*(\d+)>/i      #max number of this item 
    Item_Weight = /<weight:?\s*(.*)>/i   #weight of this item
    Stack_Size = /<stack:?\s*(\d+)>/i     #stack size of this item
  end
end

#==============================================================================
# ** Rest of the script
#==============================================================================

module RPG
  class Item < UsableItem
    include Feature_Plus::Inventory_System
       
    def item_weight
      return @item_weight unless @item_weight.nil?
      res = Item_Weight.match(self.note)
      return @item_weight = res ? res[1].to_f : (key_item? ? Default_KeyItem_Weight : Default_Item_Weight)
    end
    
    def item_stack
      return @item_stack unless @item_stack.nil?
      res = Stack_Size.match(self.note)
      return @item_stack = res ? res[1].to_i : Default_Item_Stack
    end
    
    def item_limit
      return @item_limit unless @item_limit.nil?
      res = Item_Limit.match(self.note)
      return @item_limit = res ? res[1].to_i : $game_variables[15]#Inventory_Limit
    end
  end

  class EquipItem < BaseItem
    include Feature_Plus::Inventory_System

    def item_weight
      return @item_weight unless @item_weight.nil?
      res = Item_Weight.match(self.note)
      return @item_weight = res ? res[1].to_f : Default_Equip_Weight
    end
    
    def item_stack
      return @item_stack unless @item_stack.nil?
      res = Stack_Size.match(self.note)
      return @item_stack = res ? res[1].to_i : Default_Equip_Stack
    end
    
    def item_limit
      return @item_limit unless @item_limit.nil?
      res = Item_Limit.match(self.note)
      return @item_limit = res ? res[1].to_i : $game_variables[15]#Inventory_Limit
    end
  end
end

# this module is included by Game_Item, Game_Weapon, and Game_Armor
module BaseItem
  attr_reader :index          # index of item in the inventory slot
  attr_reader :count          # number of items in this stack
  attr_reader :class          #
  attr_reader :item_stack     # max items per stack
  attr_reader :item_weight    # weight per instance of item
  attr_reader :item_limit     # max number of items allowed to carry
  attr_reader :id             # database ID used to reference the type of item
  def initialize(item, index)
    super()
    init_base_attributes(item)
    @count = 0
    @index = index
    @id = item.id
    @item_stack = item.item_stack
    @item_weight = item.item_weight
    @item_limit = item.item_limit
    setup(item, index) if needs_setup?(item)
  end
  
  def setup(item, index)
  end
  
  def init_base_attributes(item)
    item.instance_variables.each do |attr|
      self.instance_variable_set(attr, item.instance_variable_get(attr))
    end
  end
  
  def amount_can_add?
    @item_stack - @count
  end
  
  def add_amount(amt)
    @count = [@count + amt, @item_stack].min
  end
  
  def lose_amount(amt)
    lost = [amt, @count].min
    @count = [@count - amt, 0].max
    return lost
  end
  
  def full?
    @count >= @item_stack
  end
  
  def can_add?
    return false if full?
    return true
  end
  
  def inspect
    "<%s>" % @name
  end
end

# This module is included in Game_Weapon and Game_Armor. It contains common
# methods shared by all equip items
module EquipItem

  def setup(item, index)
    # call anything from BaseItem
    super
  end
end

#==============================================================================
# ** Game_Item
#------------------------------------------------------------------------------
# This is an extension of RPG::Item. All of the methods defined in
# RPG::Item are inherited. When an item is created, it is wrapped by
# this Game_Item and all of the attributes are cloned
#==============================================================================

class Game_Item < RPG::Item
  include BaseItem  
  
  def setup(item, index)
    @class = Game_Item
  end
  
  def needs_setup?(item)
    item.class == RPG::Item
  end
  
  def ==(item)
    if item.class == RPG::Item
      return $data_items[@id] == item
    elsif item.is_a?(Game_Item)
      return self.equal?(item)
    end
    return false
  end
end

#==============================================================================
# ** Game_Weapon
#------------------------------------------------------------------------------
# This is an extension of RPG::Weapon. All of the methods defined in
# RPG::Weapon are inherited. When an item is created, it is wrapped by
# this Game_Weapon and all of the attributes are cloned
#==============================================================================

class Game_Weapon < RPG::Weapon
  include BaseItem
  include EquipItem
  
  alias :th_inventory_setup :setup
  def setup(item, index)
    @class = Game_Weapon
    @params = item.params.clone #we must clone this
    @name = item.name
    th_inventory_setup(item, index)
  end
  
  def needs_setup?(item)
    item.class == RPG::Weapon
  end
  
  def ==(item)
    if item.class == RPG::Weapon
      return $data_weapons[@id] == item
    elsif item.is_a?(Game_Weapon)
      return equal?(item)
    end
    return false
  end
end

#==============================================================================
# ** Game_Armor
#------------------------------------------------------------------------------
# This is an extension of RPG::Armor. All of the methods defined in
# RPG::Armor are inherited. When an item is created, it is wrapped by
# this Game_Armor and all of the attributes are cloned
#==============================================================================

class Game_Armor < RPG::Armor
  include BaseItem
  include EquipItem

  def setup(item, index)
    @class = Game_Armor
    @params = item.params.clone #we must clone this
    @name = item.name
  end
  
  def needs_setup?(item)
    item.class == RPG::Armor
  end
  
  def ==(item)
    if item.class == RPG::Armor
      return $data_armors[@id] == item
    elsif item.is_a?(RPG::Armor)
      return self.equal?(item)
    end
    return false
  end
end

#==============================================================================
# ** Game_Inventory
#------------------------------------------------------------------------------
# This is an inventory object. It represents a generic inventory, containing
# a set of items including common items, weapons, armors, and key items.
#
# All inventory related methods are defined and any access to the inventory
# should use the provided methods
#==============================================================================
class Game_Inventory
  include Feature_Plus::Inventory_System
  
  attr_reader :weight
  attr_reader :item_count

  def initialize
    @id = 0
    @name = ""
    @weight = 0
    @item_count = 0
    @items = {}
    @weapons = {}
    @armors = {}
    @discards = {}
    $game_variables[15]
    #@inventory_limit = Inventory_Limit
    $game_variables[12]
    #@weight_limit = Weight_Limit
  end
    
  def max_items
    $game_variables[15]
    #@inventory_limit
  end
  
  def max_weight
    $game_variables[12]
    #@weight_limit
  end
  
  def weight_exceeded?(item)
    return false unless Feature_Plus::Inventory_System::Use_Weight_Limit
    @weight + item.item_weight > $game_variables[12]#@weight_limit
  end
  
  def items_exceeded?
    return false unless Feature_Plus::Inventory_System::Use_Item_Limit
    @item_count >= $game_variables[15]#@inventory_limit$
  end
  
  def limit_reached?(item)
    items_exceeded? || weight_exceeded?(item)
  end
  
  def can_add_amount?(item)
    
    if item.item_weight > 0
      return [[max_items - @item_count, (max_weight - @weight) / item.item_weight].min, 0].max
    end
    return [max_items - @item_count, 0].max
  end
    
  def get_item_type(item)
    return @items if item.is_a?(RPG::Item)
    return @weapons if item.is_a?(RPG::Weapon)
    return @armors  if item.is_a?(RPG::Armor)
    return nil
  end
  
  def is_system_item?(item)
    return [RPG::Weapon, RPG::Armor, RPG::Item].include?(item.class)
  end
  
  def item_number(item)
    container = get_item_type(item)
    return 0 unless container && container[item.id]
    return container[item.id].count unless item.instance_variable_defined?(:@index)
    return container[item.id][item.index].nil? ? 0 : container[item.id][item.index].count
  end
  
  def has_item?(item, include_equip=false)
    item_number(item) > 0
  end
    
  def gain_item(item, amount)
    container = get_item_type(item)
    return unless container
    valid_amount = [can_add_amount?(item), amount].min
    discard_amount = amount - valid_amount
    unless limit_reached?(item)
      container[item.id] = Game_InventorySlot.new(item) unless container[item.id]
      amount_avail = [container[item.id].can_add_amount?(item), valid_amount].min
      container[item.id].gain_item(item, amount_avail)
      update_inventory(container, item, amount_avail)
    end
    update_discards(item, discard_amount)
  end
  
  def lose_item(item, amount)
    container = get_item_type(item)
    return unless container
    return unless container[item.id]
    lost = container[item.id].lose_item(item, amount)
    update_inventory(container, item, -lost)
  end
  
  def update_inventory(container, item, added)
    @weight += item.item_weight * added
    @item_count += added
  end
  
  def update_discards(item, remains)
    return unless remains > 0
    p "Discarded %d %s" %[remains, item.name]
  end
  
  def clear_inventory(include_equips=false)
    $game_party.all_members.each {|actor| actor.clear_equips} if include_equips
    @weapons.clear
    @armors.clear
    @items.clear
    @item_count = 0
    @weight = 0
  end
  
  #--------------------------------------------------------------------------
  # * Accessor methods. Returns the same things that Game_Party used
  # to return
  #--------------------------------------------------------------------------
#~   
  def get_weapon(item_id)
    slot = @weapons[item_id]
    return unless slot
    return slot.stacks[0]
  end
  
  def get_armor(item_id)
    slot = @armors[item_id]
    return unless slot
    return slot.stacks[0]
  end
  
  def items
    @items.keys.sort.collect {|id| @items[id].stacks}.flatten
  end
  
  def weapons
    @weapons.keys.sort.collect {|id| @weapons[id].stacks}.flatten
  end
  
  def armors
    @armors.keys.sort.collect {|id| @armors[id].stacks}.flatten
  end
  
  def equip_items
    weapons.concat(armors)
  end
  
  def discards
    @discards
  end

  def all_items
    items.concat(weapons).concat(armors)
  end
end

#==============================================================================
# ** Game_InventorySlot
#------------------------------------------------------------------------------
# This is an inventory slot object. It provides information about this slot
# such as the number of items and total weight. It stores an instance of
# my custom game item in an array
#==============================================================================

class Game_InventorySlot
  include Feature_Plus::Inventory_System
  
  attr_reader :item_stack
  attr_reader :count
  attr_reader :weight
  def initialize(item)
    @id = item.id
    @item = item
    @stacks = []                     # individual instances of this item
    @item_weight = item.item_weight
    @count = 0                       # number of items across all stacks
    @weight = 0                      # weight of items across all stacks
    @item_stack = item.item_stack    # number of items per stack
    @item_limit = item.item_limit
  end
  
  def [](index)
    return unless @stacks[index]
    @stacks[index]
  end
  
  def max_items
    @item_limit
  end
  
  def max_weight
    $game_variables[12]
    #Weight_Limit
  end
  
  def stack_size
    @item_stack
  end
  
  #--------------------------------------------------------------------------
  # * Return all non-nil stacks
  #--------------------------------------------------------------------------
  def stacks
    @stacks.select {|stack| !stack.nil?}
  end
  
  def slot_exceeded?
    @count >= max_items
  end

  def weight_exceeded?(item)
    return false unless Feature_Plus::Inventory_System::Use_Weight_Limit
    @weight >= max_weight
  end
  
  def can_add?(item)
    return false if slot_exceeded? || weight_exceeded?(item)
    return true
  end
  
  def can_add_amount?(item)
    if item.item_weight > 0
      return [[max_items - @count, (max_weight - @weight) / item.item_weight].min, 0].max
    end
    return [max_items - @count, 0].max
  end
  
  # gets the first available stack to add item to
  def get_stack(item)
    (0 .. @stacks.size ).find { |k| @stacks[k].nil? || @stacks[k].can_add?}
  end
  
  # gets the first non-nil stack
  def first_stack
    (0 .. @stacks.size ).find { |k| @stacks[k]}
  end
  
  def make_item(item, i)
    @stacks[i] = Game_Item.new(item, i) if item.is_a?(RPG::Item)
    @stacks[i] = Game_Weapon.new(item, i) if item.is_a?(RPG::Weapon)
    @stacks[i] = Game_Armor.new(item, i) if item.is_a?(RPG::Armor)
  end
  
  def gain_item(item, amount)
    return unless can_add?(item)
    total = amount
    while amount > 0
      i = get_stack(item)
      make_item(item, i) if @stacks[i].nil?
      stack = @stacks[i]
      amt = stack.amount_can_add?
      @stacks[i].add_amount([amount, amount - amt, 0].max)
      amount -= amt
    end
    update_slot(item, total)
  end
  
  def delete_stack(index)
    @stacks.delete_at(index) 
    @stacks.insert(index, nil)
  end
  
  def lose_item(item, amount)
    total_lost = 0
    while @count > 0 && amount > 0
      i = item.index rescue first_stack
      if i
        i = first_stack if @stacks[i].count == 0
        stack = @stacks[i]
        lost_amount = stack.lose_amount(amount)
        delete_stack(i) if @stacks[i].count == 0
        update_slot(item, -lost_amount)
        total_lost += lost_amount
        amount -= lost_amount
      end
    end
    return total_lost
  end
  
  def update_slot(item, amount)
    @count += amount
    @weight += item.item_weight * amount 
  end
end

class Game_Actor < Game_Battler
  
  alias fp_inventory_actor_initialize initialize
  def initialize(actor_id)
    fp_inventory_actor_initialize(actor_id)
    @last_skill = Game_CustItem.new
  end
  
  def clear_equips
    @equips = Array.new(equip_slots.size) { Game_CustItem.new }
  end

  #need to set up initial equips properly
  def init_equips(equips)
    @equips = Array.new(equip_slots.size) { Game_CustItem.new }
    equips.each_with_index do |item_id, i|
      etype_id = index_to_etype_id(i)
      slot_id = empty_slot(etype_id)
      if item_id > 0
        @equips[slot_id].object = get_initial_equip(etype_id == 0, item_id) if slot_id
      else
        @equips[slot_id].object = nil if slot_id
      end
    end
    refresh
  end
  
  def get_initial_equip(is_weapon, item_id)
    if is_weapon
      return Game_Weapon.new($data_weapons[item_id], 0)
    else
      return Game_Armor.new($data_armors[item_id], 0)
    end
  end
  
  def xequips
    @equips.collect {|item| item.object }
  end
  
  def armors
    @equips.select {|item| item.is_armor? }.collect {|item| item.object }
  end
  
  def change_equip(slot_id, item)
    return unless trade_item_with_party(item, equips[slot_id])
    return if item && equip_slots[slot_id] != item.etype_id
    @equips[slot_id].object = item
    refresh
  end
  
  # event command "change equipment"
  def change_equip_by_id(slot_id, item_id)
    if equip_slots[slot_id] == 0
      item = $game_party.get_weapon(item_id)
      return unless item
      change_equip(slot_id, item)
    else
      index = $game_party.get_armor(item_id)
      return unless item
      change_equip(slot_id, Game_Armor.new($data_armors[item_id], index))
    end
  end
end

#==============================================================================
# ** Game_party
#------------------------------------------------------------------------------
# All inventory access methods are re-written to allow the Inventory object
# to properly handle those requests
#==============================================================================

class Game_Party < Game_Unit

  attr_reader :inventory
  alias tsuki_inventory_party_initialize initialize
  def initialize
    tsuki_inventory_party_initialize
    @inventory = Game_Inventory.new
    @last_item = Game_CustItem.new
  end
  
  def clear_inventory(include_equip=false)
    @inventory.clear_inventory(include_equip)
  end
  
  def weight
    @inventory.weight
  end
  
  def items
    @inventory.items
  end
  
  def weapons
    @inventory.weapons
  end 
  
  def armors
    @inventory.armors
  end
  
  def equip_items
    @inventory.equip_items
  end
  
  def all_items
    @inventory.all_items
  end
  
  def item_number(item)
    @inventory.item_number(item)
  end
  
  def has_item?(item, include_equip=false)
    @inventory.has_item?(item)
  end
    
  def gain_item(item, amount, include_equip = false)
    if amount < 0
      lose_item(item, -amount, include_equip)
    else
      @inventory.gain_item(item, amount)
    end
  end
  
  def lose_item(item, amount, include_equip = false)
    @inventory.lose_item(item, amount)
  end
  
  def max_item_number(item)
    99
  end
  
  def max_weight
    @inventory.max_weight
  end
  
  def item_count
    @inventory.item_count
  end
  
  def max_items
    @inventory.max_items
  end
  
  def item_max?(item)
    item_number(item) >= max_item_number(item)
  end
  
  def get_weapon(item_id)
    @inventory.get_weapon(item_id)
  end
  
  def get_armor(item_id)
    @inventory.get_armor(item_id)
  end
end

#==============================================================================
# ** Game_CustItem
#------------------------------------------------------------------------------
# This is a variation of Game_BaseItem that stores the actual instance of
# the object rather than storing references to the database
#==============================================================================

class Game_CustItem < Game_BaseItem
  def initialize
    super
    @object = nil
  end
  
  def is_skill?;   @object.is_a?(RPG::Skill);   end
  def is_item?;    @object.is_a?(RPG::Item);    end
  def is_weapon?;  @object.is_a?(RPG::Weapon);  end
  def is_armor?;   @object.is_a?(RPG::Armor);   end
  
  def object
    return nil unless @object
    return @object 
  end
  
  def object=(item)
    @class = item.class
    @item_id = item.id if item
    @object = item
  end
  
  def set_equip(is_weapon, item_id)
    @class = is_weapon ? RPG::Weapon : RPG::Armor
    @item_id = item_id
    @object = is_weapon ? $data_weapons[item_id] : $data_armors[item_id]
  end
end

class Game_Action

  alias fp_initialize_clear_action clear
  def clear
    fp_initialize_clear_action
    @item = Game_CustItem.new
  end
  
  def set_item(item)
    @item.object = item
    self
  end
end

#==============================================================================
# ** Scenes
#==============================================================================

class Scene_Battle < Scene_Base
  
  def on_item_ok
    @item = @item_window.item
    BattleManager.actor.input.set_item(@item)
    if !@item.need_selection?
      @item_window.hide
      next_command
    elsif @item.for_opponent?
      select_enemy_selection
    else
      select_actor_selection
    end
    $game_party.last_item.object = @item
  end
end

class Scene_Menu < Scene_MenuBase
  
  alias fp_inventory_menu_start start
  def start
    fp_inventory_menu_start
    create_limit_windows
  end
    
  def create_limit_windows
    y = 48
    if Feature_Plus::Inventory_System::Use_Weight_Limit
      @weight_window = Window_Weight.new(0, Graphics.height - y - @gold_window.height)
      y += 48
    end
    if Feature_Plus::Inventory_System::Use_Item_Limit
      @item_limit_window = Window_ItemLimit.new(0, Graphics.height - y - @gold_window.height)
    end
  end
end

class Scene_Item < Scene_ItemBase
  
  alias fp_inventory_item_start start
  def start
    fp_inventory_item_start
    create_limit_windows
  end
  
  def create_limit_windows
    x = 160
    if Feature_Plus::Inventory_System::Use_Weight_Limit
      @weight_window = Window_Weight.new(Graphics.width - x, 0)
      @weight_window.z = 200
      @actor_window.z = 300
      x += 160
    end
    if Feature_Plus::Inventory_System::Use_Item_Limit
      @item_limit_window = Window_ItemLimit.new(Graphics.width - x, 0)
      @item_limit_window.z = 200
      x += 160
    end
  end
  
  alias fp_inventory_use_item use_item
  def use_item
    fp_inventory_use_item
    @weight_window.refresh if Feature_Plus::Inventory_System::Use_Weight_Limit
    @item_limit_window.refresh if  Feature_Plus::Inventory_System::Use_Item_Limit
  end
end

class Window_ItemLimit < Window_Base
  include Feature_Plus::Inventory_System

  def initialize(x, y)
    super(x, y, window_width, fitting_height(1))
    refresh
  end
  
  def window_width
    160
  end

  def refresh
    contents.clear
    draw_weight_value(4, 0)
  end
  
  def draw_weight_value(x, y)
    text = sprintf(Item_Display, item_count, item_limit)
    change_color(normal_color)    
    draw_text(x, y, self.contents.width - 4, line_height, text, 1)
  end
  
  def item_limit
    $game_party.max_items
  end
  #--------------------------------------------------------------------------
  # * Get inventory weight
  #--------------------------------------------------------------------------
  def item_count
    $game_party.item_count
  end
  #--------------------------------------------------------------------------
  # * Open Window
  #--------------------------------------------------------------------------
  def open
    refresh
    super
  end
end

class Window_Weight < Window_Base
  include Feature_Plus::Inventory_System
#--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, window_width, fitting_height(1))
    refresh
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    return 160
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    draw_weight_value(4, 0, contents.width - 8)
  end
  
  def draw_weight_value(x, y, width)
    text = sprintf(Weight_Display, weight, max_weight, weight_unit)
    change_color(normal_color)    
    draw_text(x, y, width, line_height, text, 2)
  end
  
  def weight_unit
    Weight_Unit
  end
  
  def max_weight
    $game_party.max_weight
  end
  #--------------------------------------------------------------------------
  # * Get inventory weight
  #--------------------------------------------------------------------------
  def weight
    $game_party.weight
  end
  #--------------------------------------------------------------------------
  # * Open Window
  #--------------------------------------------------------------------------
  def open
    refresh
    super
  end
end

class Game_Interpreter
  def can_add_amount?(item)
    return false if item.nil?
    item = $data_items[item] unless item.is_a?(RPG::BaseItem)
    return $game_party.inventory.can_add_amount?(item)
  end
  
  def armor(i)
    return $data_armors[i]
  end

  def weapon(i)
    return $data_weapons[i]
  end
  
  def item(i)
    return @data_items[i]
  end
end

[MasterChafa 0]

As for obtaining CURRENT (not max) weight and item carry and store them in variables, i just created a common event  which executes this script. (In this case, variables 13 and 16 for weight and items, respectively)

$game_variables[13] = $game_party.weight
$game_variables[16] = $game_party.item_count

Two formal petitions:
1- Since this script limits your capacity to carry items, there MUST be a function for getting rid of items to get free space.

2- Also, whenever you were getting an item and you haven't enuff space for it, a pop-up message telling you that.

Edited January 6, 2014 by MasterChafa

[Galv 1,387]

Closing at OP's request.

Script is outdated, check the top of the original post for other option.