Script Multi monnaie

Spoiler:

Code:

#------------------------------------------------------------------------------#
#  Galv's Item/Bank Storage
#------------------------------------------------------------------------------#
#  For: RPGMAKER VX ACE
#  Version 1.7
#------------------------------------------------------------------------------#
#  2012-10-24 - Version 1.7 - Added multiple storages controlled with variable.
#                           - Changed name to Item/Bank Storage
#                           - changed alias naming for compatibility
#  2012-10-19 - Version 1.6 - Bug fixes
#  2012-10-19 - Version 1.5 - Fixed a max gold and withdrawing issue.
#                           - Added deposit all and withdraw all gold buttons.
#                           - party gold and item limits can now be set or use
#                           - the limit from a limit breaking script. (in theory)
#  2012-10-18 - Version 1.4 - Other small fixes
#  2012-10-18 - Version 1.3 - Added banking SE
#  2012-10-18 - Version 1.2 - Added gold storage and more script calls
#  2012-10-17 - Version 1.1 - Added script calls to control stored items.
#  2012-10-16 - Version 1.0 - Released
#------------------------------------------------------------------------------#
#  An item storage script. Allows the player to store as many items as he/she
#  requires in bank-like storage that can be accessed from anywhere.
#    
#  This script differs to my "Multiple Storage containers" script in that you
#  can have "banks" that store items and gold and can be accessed from anywhere.
#  It was designed to be used for one bank, but now has option to have more if
#  required.
#
#  My "Multiple Storage Containers" script stores only items within certain
#  events that can only be accessed by activating the particular event. This was
#  designed for location specific containers like chests, barrels, etc.
#
#  Here are some script calls that might be useful:
#------------------------------------------------------------------------------#
#
#  open_storage                         # Opens the item storage scene
#
#  store_add(type, id, amount)          # creates an item in storage
#  store_rem(type, id, amount)          # destroys an item in storage
#  store_count(type, id)                # returns amount of an item in storage
#
#  bank_add(amount)                     # adds amount of gold to bank
#  bank_rem(amount)                     # removes amount of gold from bank
#  bank_count                           # returns amount of gold in bank
#
#------------------------------------------------------------------------------#
#  EXPLAINATION:
#  type      this can be "weapon", "armor" or "item"
#  id        the ID of the item/armor/weapon
#  amount    the number of the item/armor/weapon/gold you want to remove
#
#  EXAMPLE OF USE:
#  store_add("weapon", 5, 20)
#  store_rem("item", 18, 99)
#  store_count("armor", 1)
#  bank_add(100)
#------------------------------------------------------------------------------#
#  More setup options further down.
#------------------------------------------------------------------------------#
 
$imported = {} if $imported.nil?
$imported["Item_Storage"] = true
 
module Storage
 
#------------------------------------------------------------------------------#
#  SCRIPT SETUP OPTIONS
#------------------------------------------------------------------------------#
 
  # BOX VARIABLE
  BOX_VAR = 0    # This is the variable ID to use to determine which box you are
                 # adding/removing items from. Set the variable to a box number
                 # right before any add/remove or opening storage script calls
                 # to tell them which box they will affect.
                 # Set to 0 if you only want 1 box storage in your game. You
                 # then don't have to change a variable before each script call.
 
 
  # COMMAND LIST VOCAB
  BANK = "Bank"
  STORE = "Store Item"
  REMOVE = "Remove Item"
  CANCEL = "Cancel"
 
  # OTHER VOCAB
  IN_STORAGE = "In Storage"
  IN_INVENTORY = "In Inventory"
  
  GOLD_INVENTORY = "Party:"
  GOLD_BANKED = "Banked:"
  BANK_HELP = "Hold DOWN to deposit. Hold UP to withdraw." + "\n" +
              "Press R to deposit all. Press L to withdraw all."
  
 
  # OTHER OPTIONS
  SE = ["Equip2", 90, 100]        # Sound effect when storing/removing an item
  SE_BANK = ["Shop", 50, 150]     # Repeating sound effect when banking gold
                                  # ["SE Name", volume, pitch]
  
  STORE_PRICELESS = true          # Items worth 0 can be stored? true or false
  STORE_KEY = true                # Key items can be stored? true or false
 
  
  # PARTY LIMITS
  # NOTE: These limits set to 0 will use the default limits. In theory this will
  # be compatible with a limit breaker script by leaving them at 0. Or you can
  # set the party limits below to whatever you like.
  
  MAX_GOLD = 0                    # Max gold your PARTY can carry.
                                  # This will overwrite the default limit.
                                  # 0 means do not use this.
 
  MAX_ITEMS = 0                   # Max items your PARTY can carry.
                                  # This will overwrite the default limit.
                                  # 0 means do not use this.
 
 
#------------------------------------------------------------------------------#
#  SCRIPT SETUP OPTIONS
#------------------------------------------------------------------------------#
 
end
 
 
class Scene_ItemBank < Scene_MenuBase
  def start
    super
    check_storage_exists
    create_help_window
    create_command_window
    create_dummy_window
    create_bank_window
    create_number_window
    create_status_window
    create_category_window
    create_take_window
    create_give_window
    
  end
  
  def check_storage_exists
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]] = {}
    end
  end
  
  
  #--------------------------------------------------------------------------
  # Create Windows
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_BankCommand.new(Graphics.width)
    @command_window.viewport = @viewport
    @command_window.y = @help_window.height
    @command_window.set_handler(:bank,   method(:command_bank))
    @command_window.set_handler(:give,   method(:command_give))
    @command_window.set_handler(:take,    method(:command_take))
    @command_window.set_handler(:cancel, method(:return_scene))
  end
  def create_dummy_window
    wy = @command_window.y + @command_window.height
    wh = Graphics.height - wy
    @dummy_window = Window_Base.new(0, wy, Graphics.width, wh)
    @dummy_window.viewport = @viewport
  end
  def create_bank_window
    @bank_window = Window_Bank.new
    @bank_window.viewport = @viewport
    @bank_window.x = 0
    @bank_window.y = @help_window.height + @command_window.height
    @bank_window.hide
    @bank_window.set_handler(:ok,     method(:on_bank_cancel))
    @bank_window.set_handler(:cancel, method(:on_bank_cancel))
 
  end
  
  def create_number_window
    wy = @dummy_window.y
    wh = @dummy_window.height
    @number_window = Window_BankNumber.new(0, wy, wh)
    @number_window.viewport = @viewport
    @number_window.hide
    @number_window.set_handler(:ok,     method(:on_number_ok))
    @number_window.set_handler(:cancel, method(:on_number_cancel))
  end
  def create_status_window
    wx = @number_window.width
    wy = @dummy_window.y
    ww = Graphics.width - wx
    wh = @dummy_window.height
    @status_window = Window_BankItems.new(wx, wy, ww, wh)
    @status_window.viewport = @viewport
    @status_window.hide
  end
  def create_category_window
    @category_window = Window_ItemCategory.new
    @category_window.viewport = @viewport
    @category_window.help_window = @help_window
    @category_window.y = @dummy_window.y
    @category_window.hide.deactivate
    @category_window.set_handler(:ok,     method(:on_category_ok))
    @category_window.set_handler(:cancel, method(:on_category_cancel))
  end
  def create_give_window
    wy = @category_window.y + @category_window.height
    wh = Graphics.height - wy
    @give_window = Window_BankGive.new(0, wy, Graphics.width, wh)
    @give_window.viewport = @viewport
    @give_window.help_window = @help_window
    @give_window.hide
    @give_window.set_handler(:ok,     method(:on_give_ok))
    @give_window.set_handler(:cancel, method(:on_give_cancel))
    @category_window.item_window = @give_window
  end
  def create_take_window
    wy = @command_window.y + @command_window.height
    wh = Graphics.height - wy
    @take_window = Window_BankTake.new(0, wy, Graphics.width, wh)
    @take_window.viewport = @viewport
    @take_window.help_window = @help_window
    @take_window.hide
    @take_window.set_handler(:ok,     method(:on_take_ok))
    @take_window.set_handler(:cancel, method(:on_take_cancel))
    @category_window.item_window = @take_window
  end
 
  #--------------------------------------------------------------------------
  # * Activate Windows
  #--------------------------------------------------------------------------
  def activate_give_window
    @category_window.show
    @give_window.refresh
    @give_window.show.activate
    @status_window.hide
  end
  def activate_take_window
    @take_window.select(0)
    @take_window.refresh
    @take_window.show.activate
    @status_window.hide
  end
  def activate_bank_window
    @bank_window.refresh
    @bank_window.show.activate
    @help_window.set_text(Storage::BANK_HELP)
  end
 
  
  #--------------------------------------------------------------------------
  # HANDLER METHODS
  #--------------------------------------------------------------------------
  def on_category_ok
    activate_give_window
    @give_window.select(0)
  end
  def on_category_cancel
    @command_window.activate
    @dummy_window.show
    @category_window.hide
    @give_window.hide
  end
  def command_give
    @dummy_window.hide
    @category_window.show.activate
    @give_window.show
    @give_window.unselect
    @give_window.refresh
  end
  def on_give_ok
    @item = @give_window.item
    if @item.nil?
      RPG::SE.stop
      Sound.play_buzzer
      @give_window.activate
      @give_window.refresh
      return
    else
      @status_window.item = @item
      @category_window.hide
      @give_window.hide
      @number_window.set(@item, max_give)
      @number_window.show.activate
      @status_window.show
    end
  end
  def on_give_cancel
    @give_window.unselect
    @category_window.activate
    @status_window.item = nil
    @help_window.clear
  end
  def command_take
    @dummy_window.hide
    activate_take_window
    @take_window.show
    @take_window.refresh
  end
  def command_bank
    #@dummy_window.hide
    activate_bank_window
    @bank_window.show
    @bank_window.refresh
  end
  def on_bank_cancel
    @command_window.activate
    @dummy_window.show
    @category_window.hide
    @bank_window.hide
    @help_window.clear
  end
  def on_take_ok
    @item = @take_window.item
    if @item.nil? || $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].empty? || $game_party.item_number(@item) == $game_party.max_item_number(@item)
      RPG::SE.stop
      Sound.play_buzzer
      @take_window.activate
      @take_window.refresh
      return
    elsif
      @item = @take_window.item
      @status_window.item = @item
      @take_window.hide
      @number_window.set(@item, max_take)
      @number_window.show.activate
      @status_window.show
    end
  end
  def on_take_cancel
    @take_window.unselect
    @command_window.activate
    @dummy_window.show
    @take_window.hide
    @status_window.item = nil
    @help_window.clear
  end
  def on_number_ok
    RPG::SE.new(Storage::SE[0], Storage::SE[1], Storage::SE[2]).play
    case @command_window.current_symbol
    when :take
      do_take(@number_window.number)
    when :give
      do_give(@number_window.number)
    end
    end_number_input
    @status_window.refresh
  end
  def on_number_cancel
    Sound.play_cancel
    end_number_input
  end
  def end_number_input
    @number_window.hide
    case @command_window.current_symbol
    when :take
      activate_take_window
    when :give
      activate_give_window
    end
  end  
  
  #--------------------------------------------------------------------------
  # * Giving and taking methods
  #--------------------------------------------------------------------------
  def max_take
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] > $game_party.max_item_number(@item) - $game_party.item_number(@item)
      $game_party.max_item_number(@item) - $game_party.item_number(@item)
    else
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item]
    end
  end
  def max_give
    $game_party.item_number(@item)
  end
  def do_give(number)
    $game_party.lose_item(@item, number)
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] = number
    else
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] += number
    end
  end
  def do_take(number)
    return if @item.nil?
    $game_party.gain_item(@item, number)
    $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] -= number
    $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].delete(@item) if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] <= 0
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].empty?
      @take_window.activate
    end
  end
  
end # Scene_ItemBank < Scene_MenuBase
 
 
#------------------------------------------------------------------------------#
#  Window Stored Items
#------------------------------------------------------------------------------#
 
class Window_StoreList_Bank < Window_Selectable
  def initialize(x, y, width, height)
    super
    @category = :none
    @data = []
  end
  def category=(category)
    return if @category == category
    @category = category
    refresh
    self.oy = 0
  end
  def col_max
    return 2
  end
  def item_max
    @data ? @data.size : 1
  end
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  def current_item_enabled?
    enable?(@data[index])
  end
  def include?(item)
    case @category
    when :item
      item.is_a?(RPG::Item) && !item.key_item?
    when :weapon
      item.is_a?(RPG::Weapon)
    when :armor
      item.is_a?(RPG::Armor)
    when :key_item
      item.is_a?(RPG::Item) && item.key_item?
    else
      false
    end
  end
  def enable?(item)
    $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].has_key?(item)
  end
  def make_item_list
    @data = $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].keys {|item| include?(item) }
    @data.push(nil) if include?(nil)
  end
  def select_last
    select(@data.index($game_party.last_item.object) || 0)
  end
  def draw_item(index)
    item = @data[index]
    if item
      rect = item_rect(index)
      rect.width -= 4
      draw_item_name(item, rect.x, rect.y, enable?(item))
      draw_item_number(rect, item)
    end
  end
  def draw_item_number(rect, item)
    draw_text(rect, sprintf(":%2d", $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][item]), 2)
  end
  def update_help
    @help_window.set_item(item)
  end
  def refresh
    make_item_list
    create_contents
    draw_all_items
  end
end # Window_StoreList_Bank < Window_Selectable
 
 
#------------------------------------------------------------------------------#
#  Window Stored Item amount
#------------------------------------------------------------------------------#
 
class Window_BankNumber < Window_Selectable
  attr_reader :number
  def initialize(x, y, height)
    super(x, y, window_width, height)
    @item = nil
    @max = 1
    @number = 1
  end
  def window_width
    return 304
  end
  def set(item, max)
    @item = item
    @max = max
    @number = 1
    refresh
  end
  def refresh
    contents.clear
    draw_item_name(@item, 0, item_y)
    draw_number
  end
  def draw_number
    change_color(normal_color)
    draw_text(cursor_x - 28, item_y, 22, line_height, "×")
    draw_text(cursor_x, item_y, cursor_width - 4, line_height, @number, 2)
  end
  def item_y
    contents_height / 2 - line_height * 3 / 2
  end
  def cursor_width
    figures * 10 + 12
  end
  def cursor_x
    contents_width - cursor_width - 4
  end
  def figures
    return 2
  end
  def update
    super
    if active
      last_number = @number
      update_number
      if @number != last_number
        Sound.play_cursor
        refresh
      end
    end
  end
  def update_number
    change_number(1)   if Input.repeat?(:RIGHT)
    change_number(-1)  if Input.repeat?(:LEFT)
    change_number(10)  if Input.repeat?(:UP)
    change_number(-10) if Input.repeat?(:DOWN)
  end
  def change_number(amount)
    @number = [[@number + amount, @max].min, 1].max
  end
  def update_cursor
    cursor_rect.set(cursor_x, item_y, cursor_width, line_height)
  end
  
end # Window_BankNumber < Window_Selectable
 
 
#------------------------------------------------------------------------------#
#  Window Store Item Status
#------------------------------------------------------------------------------#
 
class Window_BankItems < Window_Base
  def initialize(x, y, width, height)
    super(x, y, width, height)
    @item = nil
    @page_index = 0
    refresh
  end
  def refresh
    contents.clear
    draw_possession(4, 0)
    draw_stored(4, line_height)
    draw_equip_info(4, line_height * 2) if @item.is_a?(RPG::EquipItem)
  end
  def item=(item)
    @item = item
    refresh
  end
  def draw_possession(x, y)
    rect = Rect.new(x, y, contents.width - 4 - x, line_height)
    change_color(system_color)
    draw_text(rect, Storage::IN_INVENTORY)
    change_color(normal_color)
    draw_text(rect, $game_party.item_number(@item), 2)
  end
  def draw_stored(x, y)
    rect = Rect.new(x, y, contents.width - 4 - x, line_height)
    change_color(system_color)
    draw_text(rect, Storage::IN_STORAGE)
    change_color(normal_color)
    stored_amount = $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item]
    stored_amount = 0 if stored_amount.nil?
    draw_text(rect, stored_amount, 2)
  end
  def draw_equip_info(x, y)
    status_members.each_with_index do |actor, i|
      draw_actor_equip_info(x, y + line_height * (i * 2.4), actor)
    end
  end
  def status_members
    $game_party.members[@page_index * page_size, page_size]
  end
  def page_size
    return 4
  end
  def page_max
    ($game_party.members.size + page_size - 1) / page_size
  end
  def draw_actor_equip_info(x, y, actor)
    enabled = actor.equippable?(@item)
    change_color(normal_color, enabled)
    draw_text(x, y, 112, line_height, actor.name)
    item1 = current_equipped_item(actor, @item.etype_id)
    draw_actor_param_change(x, y, actor, item1) if enabled
    draw_item_name(item1, x, y + line_height, enabled)
  end
  def draw_actor_param_change(x, y, actor, item1)
    rect = Rect.new(x, y, contents.width - 4 - x, line_height)
    change = @item.params[param_id] - (item1 ? item1.params[param_id] : 0)
    change_color(param_change_color(change))
    draw_text(rect, sprintf("%+d", change), 2)
  end
  def param_id
    @item.is_a?(RPG::Weapon) ? 2 : 3
  end
  def current_equipped_item(actor, etype_id)
    list = []
    actor.equip_slots.each_with_index do |slot_etype_id, i|
      list.push(actor.equips[i]) if slot_etype_id == etype_id
    end
    list.min_by {|item| item ? item.params[param_id] : 0 }
  end
  def update
    super
    update_page
  end
  def update_page
    if visible && Input.trigger?(:A) && page_max > 1
      @page_index = (@page_index + 1) % page_max
      refresh
    end
  end
  
end # Window_BankItems < Window_Base
 
 
#------------------------------------------------------------------------------#
#  Window Give Item
#------------------------------------------------------------------------------#
 
class Window_BankGive < Window_ItemList
  def initialize(x, y, width, height)
    super(x, y, width, height)
  end
  def current_item_enabled?
    enable?(@data[index])
  end
  def enable?(item)
    if item.is_a?(RPG::Item)
      return false if item.key_item? && !Storage::STORE_KEY
    end
    if Storage::STORE_PRICELESS
      true
    else
      item && item.price > 0
    end
  end
end
 
 
#------------------------------------------------------------------------------#
#  Window Take Item
#------------------------------------------------------------------------------#
 
class Window_BankTake < Window_StoreList_Bank
  def initialize(x, y, width, height)
    super(x, y, width, height)
  end
  def current_item_enabled?
    enable?(@data[index])
  end
  def enable?(item)
    $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][item] != 0 && $game_party.item_number(item) < $game_party.max_item_number(@item)
  end
end
 
 
#------------------------------------------------------------------------------#
#  Window Command
#------------------------------------------------------------------------------#
 
class Window_BankCommand < Window_HorzCommand
  def initialize(window_width)
    @window_width = window_width
    super(0, 0)
  end
  def window_width
    @window_width
  end
  def col_max
    return 4
  end
  def make_command_list
    add_command(Storage::BANK, :bank)
    add_command(Storage::STORE,    :give)
    add_command(Storage::REMOVE,   :take)
    add_command(Storage::CANCEL, :cancel)
  end
end
 
 
#------------------------------------------------------------------------------#
#  Window Bank
#------------------------------------------------------------------------------#
 
class Window_Bank < Window_Selectable
  def initialize
    super(0, 0, window_width, fitting_height(2))
    refresh
    @deposit_rate = 1
    @withdraw_rate = 1
  end
  def window_width
    return Graphics.width / 2
  end
  alias galv_bank_update update
  def update
    galv_bank_update
    gold_transfer if self.active
  end
  def gold_transfer
    if Input.repeat?(:DOWN) && $game_party.gold > 0 || Input.repeat?(:UP) && $game_party.gold_stored > 0 && $game_party.gold < $game_party.max_gold
        RPG::SE.new(Storage::SE_BANK[0], Storage::SE_BANK[1], Storage::SE_BANK[2]).play
    end
    if Input.press?(:DOWN)
      before = $game_party.gold
      $game_party.lose_gold(@deposit_rate)
      after = $game_party.gold
      $game_party.gold_stored += before - after
      @deposit_rate += 1
      refresh
    end
    if Input.trigger?(:R) && !Input.press?(:DOWN) && !Input.press?(:UP)
      return if $game_party.gold == 0
      before = $game_party.gold
      $game_party.lose_gold($game_party.gold)
      after = $game_party.gold
      $game_party.gold_stored += before - after
      refresh
      RPG::SE.new(Storage::SE_BANK[0], Storage::SE_BANK[1], Storage::SE_BANK[2]).play
    end
    if !Input.press?(:DOWN)
      @deposit_rate = 1
    end
    if Input.press?(:UP)
      return if $game_party.gold == $game_party.max_gold
      @withdraw_rate = $game_party.gold_stored if @withdraw_rate >= $game_party.gold_stored
      if @withdraw_rate + $game_party.gold > $game_party.max_gold
        @withdraw_rate = $game_party.max_gold - $game_party.gold
      end
      before = $game_party.gold_stored
      $game_party.gold_stored -= @withdraw_rate
      after = $game_party.gold_stored
      $game_party.gain_gold(before - after)
      if $game_party.gold_stored == 0
        return refresh
      end
      @withdraw_rate += 1
      refresh
    end
    
    if Input.trigger?(:L) && !Input.press?(:DOWN) && !Input.press?(:UP)
      take_all_gold = $game_party.gold_stored
      return if $game_party.gold == $game_party.max_gold || $game_party.gold_stored == 0
      if take_all_gold + $game_party.gold > $game_party.max_gold
        take_all_gold = $game_party.max_gold - $game_party.gold
      end
      before = $game_party.gold_stored
      $game_party.gold_stored -= take_all_gold
      after = $game_party.gold_stored
      $game_party.gain_gold(before - after)
      refresh
      RPG::SE.new(Storage::SE_BANK[0], Storage::SE_BANK[1], Storage::SE_BANK[2]).play
    end
    if !Input.press?(:UP)
      @withdraw_rate = 1
    end
  end
  def refresh
    contents.clear
    draw_gold_location(Storage::GOLD_INVENTORY, 0, 0, 250)
    draw_currency_value(value, currency_unit, 4, 0, contents.width -
    draw_gold_location(Storage::GOLD_BANKED, 0, line_height * 1, 250)
    draw_currency_value(value_stored, currency_unit, 4, line_height * 1, contents.width -
  end
  def draw_gold_location(vocab, x, y, width)
    change_color(system_color)
    draw_text(x, y, width, line_height, vocab)
  end
  def value
    $game_party.gold
  end
  def value_stored
    $game_party.gold_stored
  end
  def currency_unit
    Vocab::currency_unit
  end
  def open
    refresh
    super
  end
end
 
 
#------------------------------------------------------------------------------#
#  Game Party Additions
#------------------------------------------------------------------------------#
 
 
class Game_Party < Game_Unit
  attr_accessor :multi_storage
  attr_accessor :gold_stored
  
  alias galv_bank_init_all_items init_all_items
  def init_all_items
    galv_bank_init_all_items
    @storage = {}
    @stored_items = {}
    @stored_weapons = {}
    @stored_armors = {}
    @gold_stored = 0
  end
  
  def multi_storage
    @storage
  end
  def storage
    @stored_items
    @stored_weapons
    @stored_armors
  end
  def gold_stored
    @gold_stored
  end
 
  alias galv_bank_max_gold max_gold
  def max_gold
    return Storage::MAX_GOLD if Storage::MAX_GOLD > 0
    galv_bank_max_gold
  end
  
  alias galv_bank_max_item_number max_item_number
  def max_item_number(item)
    return Storage::MAX_ITEMS if Storage::MAX_ITEMS > 0
    return 99 if item.nil?
    galv_bank_max_item_number(item)
  end
  
end # Game_Party < Game_Unit
 
 
class Game_Interpreter
  def store_add(type, id, amount)
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]] = {}
    end
    case type
    when "weapon"
      @item = $data_weapons[id]
    when "item"
      @item = $data_items[id]
    when "armor"
      @item = $data_armors[id]
    end
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] = amount
    else
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] += amount
    end
  end
  def store_rem(type, id, amount)
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]] = {}
    end
    case type
    when "weapon"
      @item = $data_weapons[id]
    when "item"
      @item = $data_items[id]
    when "armor"
      @item = $data_armors[id]
    end
    return if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item].nil?
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] <= amount
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].delete(@item)
    else
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item] -= amount
    end
  end
  def store_count(type, id)
    if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]].nil?
      $game_party.multi_storage[$game_variables[Storage::BOX_VAR]] = {}
    end
    case type
    when "weapon"
      @item = $data_weapons[id]
    when "item"
      @item = $data_items[id]
    when "armor"
      @item = $data_armors[id]
    end
    return 0 if $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item].nil?
    $game_party.multi_storage[$game_variables[Storage::BOX_VAR]][@item]
  end
  def bank_add(amount)
    $game_party.gold_stored += amount
  end
  def bank_rem(amount)
    $game_party.gold_stored -= amount
    $game_party.gold_stored = 0 if $game_party.gold_stored < 0
  end
  def bank_count
    $game_party.gold_stored
  end
  def open_storage
    SceneManager.call(Scene_ItemBank)
  end
end

Je peut aussi ajouter la possibilité d'assigner plusieurs prix au objet ce que je veut dire c'est par exemple une potion peut être acheter 200 pièce de cuivre ou 20 pièce d'argent ou 2 pièce d'or par exemple

Code:


if Monnaie::YANFLY_MENU
  @gold_window.height = 24+24*array.length
  @gold_window.y = 0
end

Code:


w *= 1.2 if i.to_s.length == 1


Code:

############################
# Modif pour le menu craft #
############################
if Monnaie::CRAFT_MENU
  $crafting_monnaie = :all
  class Scene_CraftingAll < Scene_Base

Code:

############################
# Modif pour le menu craft #
############################
if Monnaie::CRAFT_MENU
  $crafting_monnaie = :all
  class Scene_CraftingAll

Vincent26 a écrit:Le principe :
Ce script permet d'ajouter des monnaie au jeu pour ne plus être limiter a une monnaie unique. Il inclut un menu de conversion des différentes monnaie.
De plus les monnaie peuvent être représenter par une icone ou leur nom (au choix)