¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 [RPG Maker XP] Item Limit V 0.3 el Dom Ago 28, 2011 2:44 am

MidnightMoon

avatar
Item Limit
La idea es la siguiente:
  • Permite limitar por objeto el numero que se puede tener de items de ese objeto, en dado caso de superar ese numero de objetos crea un nuevo bloque para almacenar mas de ese objeto. Al estilo Juego MMORPG (Creo que lo escribi bien)
  • Se puede limitar el numero de bloques que tendras de cada objeto, asi digamos, se puede tener dos bloques de 20 objets cada uno.
  • Estos dos parametros se podran modificar mientras se este jugando con unas llamadas al script.
  • Permite por ende crear bloques que almacenen mas de 99 objetos de un tipo.
  • Permite Limitar el dinero, y poder incrementar o decrementar este limite en ejecucion
  • Compatible con Bag_System.


Ya colgue demo, aunque sigue siendo BETA ya es usable hasta cierto grado, el demo viene con el Bag System para que los puedan ver en conjunto

Código:

#======================================================================#
#  Scene Limit V 0.3                                                  #
#  ****** By Midnight Moon                                ******      #
# Descripcion: Script que permite limitar el numero de items,         
#  asi como, si se supera el el numero de item dar posibilidad
#  de crear otro bloque para almacenar mas items o no.
#  De igual manera tambien permite aumentar en ejecucion el total
#  de bloques o el limite en cada bloque.
#======================================================================#
module ConfigIItemLimit
#======================================================================#
  # Aqui se definiran los items, armors o weapons. Asi como el tamaño que ocupan
  #  y de igual manera cuantos items componen un grupo de ese item.
  # Esto solo es un default se puede cambiar en ejecucion.
  # En caso de no especificar, los items ocuparan 0 espacios y se podran tener el default
  # El formato para declarar uno es en su seccion correspondiente, de la siguiente manera:
  # id_item/armor/weapon => [total_de_bloques, total_por_bloque]
  # Ejemplos:
  # 12 => [0, 20] Indica que del item 12 ocupara un bloque y se podra tener n bloques.
  # 13 => [1, 0] Si se pone 0 es el default, quiere decir que se podran poner hasta 99 items y solo se podra tener un bloque de este item.
 
  #  Items:
  DataIItems = {
    1 => [2, 20],
    2 => [5, 150]
  }
  #  Armors:
  DataIArmors = {
  }
  #  Weapons
  DataIWeapons = {
    1 => [3, 1]
  }
 
  # Aqui se podra limitar el Dinero, el valor aqui ingresado es solo el de comienzo
  # Pero en cualquier parte del juego  se puede expandir o reducir
  # con el comando $game_party.expand_gold(n)
  # Pudiendo ser n negativo o positivo
  DataIGold = 999999
 
#======================================================================#
# Estas configuraciones se pueden modificar a mitad del juego con los siguientes comandos.
# expand_block_item(item_id, n)
# expand_block_weapon(weapon_id, n)
# expand_block_armor(armor_id, n)
#
# expand_limit_item(item_id, n)
# expand_limit_weapon(weapon_id, n)
# expand_limit_armor(armor_id, n)
#
# Los que dicen block es para expandir o reducir los bloques, y los que dicen limit el limite por bloque.
# n puede ser negativo o positivo.
# Si al hacer la resta o suma, da como resultado menor a cero, este se pondra como 0.
# Ya se especifico arriba para que sirve el cero en cualquiera de las dos opciones.
#
# Ejemplos:
#  $game_party.expand_block_item(3, 4)
#  $game_party.expand_limit_armor(10, 2)
#======================================================================#
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
  include ConfigIItemLimit
 
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :items_blocks
  attr_reader :weapons_blocks
  attr_reader :armors_blocks
 
  alias midnightmoon_itemlimit_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    midnightmoon_itemlimit_initialize
   
    @item_limit = true
    @items_blocks = {}
    @weapons_blocks = {}
    @armors_blocks = {}
    @items_size = DataIItems
    @weapons_size = DataIWeapons
    @armors_size = DataIArmors
    @gold_limit = DataIGold
  end
  #--------------------------------------------------------------------------
  # * Gain Gold (or lose)
  #    n : amount of gold
  #--------------------------------------------------------------------------
  def gain_gold(n)
    @gold = [[@gold + n, 0].max, @gold_limit].min
  end
  #--------------------------------------------------------------------------
  # * Gain Items (or lose)
  #    item_id : item ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_item(item_id, n)
    if item_id > 0
      gain_item_normal(item_id, n)
      gain_item_block(item_id, n)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Items Normal (or lose)
  #    item_id : item ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_item_normal(item_id, n)
    # Se suma la variable comun de @items
    if @items_size[item_id].nil?
      @items[item_id] = [[item_number(item_id) + n, 0].max, 99].min
    else
      if @items_size[item_id][0] == 0
        @items[item_id] = [item_number(item_id) + n, 0].max
      else
        @items[item_id] = [[item_number(item_id) + n, 0].max, @items_size[item_id][0] * @items_size[item_id][1]].min
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Items Block (or lose)
  #    item_id : item ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_item_block(item_id, n)
    # Se crea un nuevo arreglo en caso de no exista.
    if @items_blocks[item_id].nil?
      @items_blocks[item_id] = Array.new
    end
   
    maximo = @items_size.include?(item_id) ? @items_size[item_id][1] : 99
    maximo = 99 if maximo == 0
    bloques = @items_size.include?(item_id) ? @items_size[item_id][0] : 0
    num = n
    @items_blocks[item_id].each_index do |s|
      if @items_blocks[item_id][s] < maximo
        if (@items_blocks[item_id][s] + num) > maximo
          num = (num + @items_blocks[item_id][s]) - maximo
          @items_blocks[item_id][s] = maximo
        else
          @items_blocks[item_id][s] += num
          if @items_blocks[item_id][s] <= 0
            num = @items_blocks[item_id][s]
            @items_blocks[item_id][s] = 0
          else
            num = 0
          end
        end
      else
        if num < 0
          @items_blocks[item_id][s] += num
          if @items_blocks[item_id][s] <= 0
            num = @items_blocks[item_id][s]
            @items_blocks[item_id][s] = 0
          else
            num = 0
          end
        end
      end
      break if num == 0
    end
   
    @items_blocks[item_id].delete_if {|x| x == 0 }
   
    loop do
      break if num == 0 || ((@items_blocks[item_id].size >= bloques) && bloques != 0)
      if num > maximo
        @items_blocks[item_id].push(maximo)
        num -= maximo
      else
        @items_blocks[item_id].push(num)
        num = 0
      end
    end
    #if ((@items_blocks[item_id].size < bloques) && bloques != 0) || num == 0
  end
  #--------------------------------------------------------------------------
  # * Gain Weapons (or lose)
  #    weapon_id : weapon ID
  #    n        : quantity
  #--------------------------------------------------------------------------
  def gain_weapon(weapon_id, n)
    if weapon_id > 0
      gain_weapon_normal(weapon_id, n)
      gain_weapon_block(weapon_id, n)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Weapons Normal (or lose)
  #    weapon_id : Weapon ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_weapon_normal(weapon_id, n)
    # Se suma la variable comun de @items
    if @weapons_size[weapon_id].nil?
      @weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, 99].min
    else
      if @weapons_size[weapon_id][0] == 0
        @weapons[weapon_id] = [weapon_number(weapon_id) + n, 0].max
      else
        @weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, @weapons_size[weapon_id][0] * @weapons_size[weapon_id][1]].min
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Weapons Block (or lose)
  #    weapon_id : Weapon ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_weapon_block(weapon_id, n)
    # Se crea un nuevo arreglo en caso de no exista.
    if @weapons_blocks[weapon_id].nil?
      @weapons_blocks[weapon_id] = Array.new
    end
   
    maximo = @weapons_size.include?(weapon_id) ? @weapons_size[weapon_id][1] : 99
    maximo = 99 if maximo == 0
    bloques = @weapons_size.include?(weapon_id) ? @weapons_size[weapon_id][0] : 0
    num = n
    @weapons_blocks[weapon_id].each_index do |s|
      if @weapons_blocks[weapon_id][s] < maximo
        if (@weapons_blocks[weapon_id][s] + num) > maximo
          num = (num + @weapons_blocks[weapon_id][s]) - maximo
          @weapons_blocks[weapon_id][s] = maximo
        else
          @weapons_blocks[weapon_id][s] += num
          if @weapons_blocks[weapon_id][s] <= 0
            num = @weapons_blocks[weapon_id][s]
            @weapons_blocks[weapon_id][s] = 0
          else
            num = 0
          end
        end
      else
        if num < 0
          @weapons_blocks[weapon_id][s] += num
          if @weapons_blocks[weapon_id][s] <= 0
            num = @weapons_blocks[weapon_id][s]
            @weapons_blocks[weapon_id][s] = 0
          else
            num = 0
          end
        end
      end
      break if num == 0
    end
   
    @weapons_blocks[weapon_id].delete_if {|x| x == 0 }
   
    loop do
      break if num == 0 || ((@weapons_blocks[weapon_id].size >= bloques) && bloques != 0)
      if num > maximo
        @weapons_blocks[weapon_id].push(maximo)
        num -= maximo
      else
        @weapons_blocks[weapon_id].push(num)
        num = 0
      end
    end
    # if ((@weapons_blocks[weapon_id].size < bloques) && bloques != 0) || num == 0
  end
 
  #--------------------------------------------------------------------------
  # * Gain Armor (or lose)
  #    armor_id : armor ID
  #    n        : quantity
  #--------------------------------------------------------------------------
  def gain_armor(armor_id, n)
    if armor_id > 0
      gain_armor_normal(armor_id, n)
      gain_armor_block(armor_id, n)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Armors Normal (or lose)
  #    armor_id : Armor ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_armor_normal(armor_id, n)
    # Se suma la variable comun de @items
    if @armors_size[armor_id].nil?
      @armors[armor_id] = [[armor_number(armor_id) + n, 0].max, 99].min
    else
      if @armors_size[armor_id][0] == 0
        @armors[armor_id] = [armor_number(armor_id) + n, 0].max
      else
        @armors[armor_id] = [[armor_number(armor_id) + n, 0].max, @armors_size[armor_id][0] * @armors_size[armor_id][1]].min
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Gain Armors Block (or lose)
  #    armor_id : Armor ID
  #    n      : quantity
  #--------------------------------------------------------------------------
  def gain_armor_block(armor_id, n)
    # Se crea un nuevo arreglo en caso de no exista.
    if @armors_blocks[armor_id].nil?
      @armors_blocks[armor_id] = Array.new
    end
   
    maximo = @armors_size.include?(armor_id) ? @armors_size[armor_id][1] : 99
    maximo = 99 if maximo == 0
    bloques = @armors_size.include?(armor_id) ? @armors_size[armor_id][0] : 0
    num = n
    @armors_blocks[armor_id].each_index do |s|
      if @armors_blocks[armor_id][s] < maximo
        if (@armors_blocks[armor_id][s] + num) > maximo
          num = (num + @armors_blocks[armor_id][s]) - maximo
          @armors_blocks[armor_id][s] = maximo
        else
          @armors_blocks[armor_id][s] += num
          if @armors_blocks[armor_id][s] <= 0
            num = @armors_blocks[armor_id][s]
            @armors_blocks[armor_id][s] = 0
          else
            num = 0
          end
        end
      else
        if num < 0
          @armors_blocks[armor_id][s] += num
          if @armors_blocks[armor_id][s] <= 0
            num = @armors_blocks[armor_id][s]
            @armors_blocks[armor_id][s] = 0
          else
            num = 0
          end
        end
      end
      break if num == 0
    end
   
    @armors_blocks[armor_id].delete_if {|x| x == 0 }
   
    loop do
      break if num == 0 || ((@armors_blocks[armor_id].size >= bloques) && bloques != 0)
      if num > maximo
        @armors_blocks[armor_id].push(maximo)
        num -= maximo
      else
        @armors_blocks[armor_id].push(num)
        num = 0
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Use Items
  #    item_id : Item ID
  #    block      : Block
  #--------------------------------------------------------------------------
  def use_item(item_id, block)
    # Update quantity data in the hash.
    if item_id > 0
      gain_item_normal(item_id, -1)
      # Revision en los bloques ya existentes, añade o quita.
      @items_blocks[item_id].each_index do |s|
        if s == block
          @items_blocks[item_id][s] -= 1
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Discard Item Block
  #    item_id : Item ID
  #    n      : quantity
  #    block  : Block
  #--------------------------------------------------------------------------
  def discard_item_block(item_id, n, block)
    if item_id > 0
      gain_item_normal(item_id, n)
      # Revision en los bloques ya existentes, añade o quita.
      @items_blocks[item_id].each_index do |s|
        if s == block
          @items_blocks[item_id][s] += n
          @items_blocks[item_id][s] = 0 if @items_blocks[item_id][s] < 0
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Discard Weapon Block
  #    weapon_id : Weapon ID
  #    n      : quantity
  #    block  : Block
  #--------------------------------------------------------------------------
  def discard_weapon_block(weapon_id, n, block)
    # Update quantity data in the hash.
    if weapon_id > 0
      gain_weapon_normal(weapon_id, n)
      # Revision en los bloques ya existentes, añade o quita.
      @weapons_blocks[weapon_id].each_index do |s|
        if s == block
          @weapons_blocks[weapon_id][s] += n
          @weapons_blocks[weapon_id][s] = 0 if @weapons_blocks[weapon_id][s] < 0
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Discard Armor Block
  #    armor_id : Armor ID
  #    n      : quantity
  #    block  : Block
  #--------------------------------------------------------------------------
  def discard_armor_block(armor_id, n, block)
    # Update quantity data in the hash.
    if armor_id > 0
      gain_armor_normal(armor_id, n)
      # Revision en los bloques ya existentes, añade o quita.
      @armors_blocks[armor_id].each_index do |s|
        if s == block
          @armors_blocks[armor_id][s] += n
          @armors_blocks[armor_id][s] = 0 if @armors_blocks[armor_id][s] < 0
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * Clear Item
  # Limpia los bloques que tengan 0 de cada objeto
  #    item_id : Item ID
  #--------------------------------------------------------------------------
  def clear_item(item_id)
    # Eliminamos los bloques donde el total sea igual a cero
    @items_blocks[item_id].delete_if {|x| x == 0 }
  end
 
  #--------------------------------------------------------------------------
  # * Clear Weapon
  # Limpia los bloques que tengan 0 de cada objeto
  #    weapon_id : Weapon ID
  #--------------------------------------------------------------------------
  def clear_weapon(weapon_id)
    # Eliminamos los bloques donde el total sea igual a cero
    @weapons_blocks[weapon_id].delete_if {|x| x == 0 }
  end
 
  #--------------------------------------------------------------------------
  # * Clear Armor
  # Limpia los bloques que tengan 0 de cada objeto
  #    armor_id : Armor ID
  #--------------------------------------------------------------------------
  def clear_armor(armor_id)
    # Eliminamos los bloques donde el total sea igual a cero
    @armors_blocks[armor_id].delete_if {|x| x == 0 }
  end
 
  #--------------------------------------------------------------------------
  # * Expand Block Item
  #    item_id : Item ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_block_item(item_id, n)
    if @items_size.include?(item_id)
      @items_size[item_id][0] = [@items_size[item_id][0] + n, 0].max
      if n < 0
        optimize_item(item_id)
      end
    else
      @items_size[item_id] = Array.new
      @items_size[item_id][0] = [n, 0].max
      @items_size[item_id][1] = 0
      @items_blocks[item_id] = Array.new
      optimize_item(item_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Expand Block Weapon
  #    item_id : Weapon ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_block_weapon(weapon_id, n)
    if @weapons_size.include?(weapon_id)
      @weapons_size[weapon_id][0] = [@weapons_size[weapon_id][0] + n, 0].max
      if n < 0
        optimize_weapon(weapon_id)
      end
    else
      @weapons_size[weapon_id] = Array.new
      @weapons_size[weapon_id][0] = [n, 0].max
      @weapons_size[weapon_id][1] = 0
      @weapons_blocks[weapon_id] = Array.new
      optimize_weapon(weapon_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Expand Block Armor
  #    item_id : Armor ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_block_armor(armor_id, n)
    if @armors_size.include?(armor_id)
      @armors_size[armor_id][0] = [@armors_size[armor_id][0] + n, 0].max
      if n < 0
        optimize_armor(armor_id)
      end
    else
      @armors_size[armor_id] = Array.new
      @armors_size[armor_id][0] = [n, 0].max
      @armors_size[armor_id][1] = 0
      @armors_blocks[armor_id] = Array.new
      optimize_armor(armor_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Expand Limit Item
  #    item_id : Item ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_limit_item(item_id, n)
    if @items_size.include?(item_id)
      @items_size[item_id][1] = [@items_size[item_id][1] + n, 0].max
    else
      @items_size[item_id] = Array.new
      @items_size[item_id][1] = [n, 0].max
      @items_size[item_id][0] = 0
      @items_blocks[item_id] = Array.new
    end
    optimize_item(item_id)
  end
 
  #--------------------------------------------------------------------------
  # * Expand Limit Weapon
  #    weapon_id : Weapon ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_limit_weapon(weapon_id, n)
    if @weapons_size.include?(weapon_id)
      @weapons_size[weapon_id][1] = [@weapons_size[weapon_id][1] + n, 0].max
    else
      @weapons_size[weapon_id] = Array.new
      @weapons_size[weapon_id][1] = [n, 0].max
      @weapons_size[weapon_id][0] = 0
      @weapons_blocks[weapon_id] = Array.new
    end
    optimize_weapon(weapon_id)
  end
 
  #--------------------------------------------------------------------------
  # * Expand Limit Armor
  #    armor_id : Armor ID
  #    n      : Quantity
  #--------------------------------------------------------------------------
  def expand_limit_armor(armor_id, n)
    if @armors_size.include?(armor_id)
      @armors_size[armor_id][1] = [@armors_size[armor_id][1] + n, 0].max
    else
      @armors_size[armor_id] = Array.new
      @armors_size[armor_id][1] = [n, 0].max
      @armors_size[armor_id][0] = 0
      @armors_blocks[armor_id] = Array.new
    end
    optimize_armor(armor_id)
  end
 
  #--------------------------------------------------------------------------
  # * Optimize Item
  #    item_id : Item ID
  #--------------------------------------------------------------------------
  def optimize_item(item_id)
    if item_id > 0
      num = item_number(item_id)
      maximo = @items_size.include?(item_id) ? @items_size[item_id][1] : 99
      maximo = 99 if maximo == 0
      bloques = @items_size.include?(item_id) ? @items_size[item_id][0] : 0
      @items_blocks[item_id].clear
     
      loop do
        if num > maximo
          @items_blocks[item_id].push(maximo)
          num -= maximo
        else
          @items_blocks[item_id].push(num)
          num = 0
        end
        break if num == 0 || ((@items_blocks[item_id].size >= bloques) && bloques != 0)
      end
      gain_item_normal(item_id, -num)
      clear_item(item_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Optimize Armor
  #    armor_id : Armor ID
  #--------------------------------------------------------------------------
  def optimize_armor(armor_id)
    if armor_id > 0
      num = armor_number(armor_id)
      maximo = @armor_size.include?(armor_id) ? @armor_size[armor_id][1] : 99
      maximo = 99 if maximo == 0
      bloques = @armor_size.include?(armor_id) ? @armor_size[armor_id][0] : 0
      @armors_blocks[armor_id].clear
     
      loop do
        if num > maximo
          @armors_blocks[armor_id].push(maximo)
          num -= maximo
        else
          @armors_blocks[armor_id].push(num)
          num = 0
        end
        break if num == 0 || ((@armors_blocks[armor_id].size >= bloques) && bloques != 0)
      end
      gain_armor_normal(armor_id, -num)
      clear_armor(armor_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Optimize Weapon
  #    weapon_id : Weapon ID
  #--------------------------------------------------------------------------
  def optimize_weapon(weapon_id)
    if weapon_id > 0
      num = weapon_number(weapon_id)
      maximo = @weapons_size.include?(weapon_id) ? @weapons_size[weapon_id][1] : 99
      maximo = 99 if maximo == 0
      bloques = @weapons_size.include?(weapon_id) ? @weapons_size[weapon_id][0] : 0
      @weapons_blocks[weapon_id].clear
     
      loop do
        if num > maximo
          @weapons_blocks[weapon_id].push(maximo)
          num -= maximo
        else
          @weapons_blocks[weapon_id].push(num)
          num = 0
        end
        break if num == 0 || ((@weapons_blocks[weapon_id].size >= bloques) && bloques != 0)
      end
      gain_weapon_normal(weapon_id, -num)
      clear_weapon(weapon_id)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Expand Gold (o reduce)
  #    n : Quantity
  #--------------------------------------------------------------------------
  def expand_gold(n)
    @gold_limit += n
    if n < 0 && @gold_limit < @gold
      @gold = @gold_limit
    end
  end
end

#==============================================================================
# ** Window_Item
#------------------------------------------------------------------------------
#  This window displays items in possession on the item and battle screens.
#==============================================================================

class Window_Item < Window_Selectable
  include ConfigIItemLimit
 
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Add item
    for i in 1...$data_items.size
      if $game_party.item_number(i) > 0
        $game_party.items_blocks[i].each_index do |s|
          @data.push([$data_items[i], s])
        end
      end
    end
    # Also add weapons and items if outside of battle
    unless $game_temp.in_battle
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0
          $game_party.weapons_blocks[i].each_index do |s|
            @data.push([$data_weapons[i], s])
          end
        end
      end
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0
          $game_party.armors_blocks[i].each_index do |s|
            @data.push([$data_armors[i], s])
          end
        end
      end
    end
    # If item count is not 0, make a bit map and draw all items
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #    index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index][0]
    case item
    when RPG::Item
      number = $game_party.items_blocks[item.id][@data[index][1]]
    when RPG::Weapon
      number = $game_party.weapons_blocks[item.id][@data[index][1]]
    when RPG::Armor
      number = $game_party.armors_blocks[item.id][@data[index][1]]
    end
    if item.is_a?(RPG::Item) and
      $game_party.item_can_use?(item.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
  #--------------------------------------------------------------------------
  # * Help Text Update
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(self.item == nil ? "" : self.item[0].description)
  end
end

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

class Scene_Item
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Menu.new(0)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Get currently selected data on the item window
      if @item_window.item != nil
        @item = @item_window.item[0]
        @item_index = @item_window.item[1]
      else
        @item = nil
      end
      if @item != nil
        # If not a use item
        unless @item.is_a?(RPG::Item)
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # If it can't be used
        unless $game_party.item_can_use?(@item.id)
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # If effect scope is an ally
        if @item.scope >= 3
          # Activate target window
          @item_window.active = false
          @target_window.x = (@item_window.index + 1) % 2 * 304
          @target_window.visible = true
          @target_window.active = true
          # Set cursor position to effect scope (single / all)
          if @item.scope == 4 || @item.scope == 6
            @target_window.index = -1
          else
            @target_window.index = 0
          end
        # If effect scope is other than an ally
        else
          # If command event ID is valid
          if @item.common_event_id > 0
            # Command event call reservation
            $game_temp.common_event_id = @item.common_event_id
            # Play item use SE
            $game_system.se_play(@item.menu_se)
            # If consumable
            if @item.consumable
              # Decrease used items by 1
              $game_party.use_item(@item.id, @item_index)
              # Draw item window item
              @item_window.draw_item(@item_window.index)
              if $game_party.items_blocks[@item.id][@item_index] == 0
                # Play cancel SE
                $game_system.se_play($data_system.cancel_se)
                $game_party.clear_item(@item.id)
                # If unable to use because items ran out
                @item_window.refresh
              end
            end
            # Switch to map screen
            $scene = Scene_Map.new
            return
          end
        end
        return
      else
        $game_system.se_play($data_system.buzzer_se)
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # If unable to use because items ran out
      unless $game_party.item_can_use?(@item.id)
        # Remake item window contents
        @item_window.refresh
      end
      # Erase target window
      @item_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If target is all
      if @target_window.index == -1
        # Apply item effects to entire party
        used = false
        for i in $game_party.actors
          used |= i.item_effect(@item)
        end
      end
      # If single target
      if @target_window.index >= 0
        # Apply item use effects to target actor
        target = $game_party.actors[@target_window.index]
        used = target.item_effect(@item)
      end
      # If an item was used
      if used
        # Play item use SE
        $game_system.se_play(@item.menu_se)
        # If consumable
        if @item.consumable
          # Decrease used items by 1
          $game_party.use_item(@item.id, @item_index)
          # Redraw item window item
          @item_window.draw_item(@item_window.index)
          if $game_party.items_blocks[@item.id][@item_index] == 0
            # Play cancel SE
            $game_system.se_play($data_system.cancel_se)
            $game_party.clear_item(@item.id)
            # If unable to use because items ran out
            @item_window.refresh
            # Erase target window
            @item_window.active = true
            @target_window.visible = false
            @target_window.active = false
            return
          end
        end
        # Remake target window contents
        @target_window.refresh
        # If all party members are dead
        if $game_party.all_dead?
          # Switch to game over screen
          $scene = Scene_Gameover.new
          return
        end
        # If common event ID is valid
        if @item.common_event_id > 0
          # Common event call reservation
          $game_temp.common_event_id = @item.common_event_id
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      # If item wasn't used
      unless used
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
      end
      return
    end
  end
end

Imagenes:
Spoiler:




Demo:
El Demo viene en conjunto al Item_Limit, si desean quitarlo pues eliminenlo para probarlo sin Item_Limit
mediafire.com ?1kn8s7ow489dkg9

Dudas, sugerencias, quejas, etc favor de comentar... Errores tambien para depurarlos

SAYONARA



Última edición por MidnightMoon el Sáb Sep 03, 2011 11:26 pm, editado 3 veces

#2 Re: [RPG Maker XP] Item Limit V 0.3 el Miér Ago 31, 2011 5:56 pm

Razor

avatar
Buen script Midnight, como siempre vengo con una incentivación a que sigas publicando tus scripts y también con una duda:

¿Este script te permite limitar el dinero?
¿Te permite limitar las armas/protectores/armadura equipo en general?

Esas son las únicas dudas acerca del script y si no las integra sería bueno que las integraras en tu próxima versión del script.

¡Un Saludo!
Out~





Todos mis aportes por Mediafire tienen contraseña, esa es: www.universomaker.net
Esto es para evitar plagio, asegúrense de copiar y pegar la contraseña.

#3 Re: [RPG Maker XP] Item Limit V 0.3 el Miér Ago 31, 2011 6:39 pm

MidnightMoon

avatar
El dinero no porque no lo tenia considerado... aunque seria una buena opcion XD
Y el equipo si lo puedes limitar igual que los items, ahi viene explicado en la configuracion.

Con el script Bag_System que estoy desarrollando se podra limitar el tamaño de tu bolsa. Asi como un par de cosas mas.

SAYONARA

Contenido patrocinado


Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.