#==============================================================================
# Limited Inventory
# Version: 1.0
# Author: rusted_71
# Date: July 26, 2010
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Description:
# Script ini berguna untuk membatasi inventory / item yang di bawah oleh
# party
# party dapat membawa satu jenis barang sampai batas maksimal (default = 99)
# namun untuk weapon dan armor party hanya dapat membawa satu (jika mendapat
# weapon atau armor yang sama akan memerlukan slot baru pada inventory)
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Instructions:
# Untuk awal penggunaan copi paste script ini di atas main dan di bawah
# semua custom script...
#
# Setelah itu untuk kenyamanan penggunaan harap lakukan beberapa perubahan
# pada default script, sebagai berikut
#
# pada Scene_Item baris 141 (# Erase target window)
# ubahlah baris di bawahnya, dari
#
# @target_window.visible = false
#
# menjadi
#
# @target_window.index = -2
#
# untuk pengaturan selanjutnya dapat diliat petunjuk pada module RUSTED_ITEM
#
# di dalam game kamu dapat mengubah besarnya slot inventory party dengan cara
# ketikan code dibawah ini pada script di event
#
# resize_inventory(new_size)
#
# new_size dapat diisi angka yang lebih besar atau lebih kecil dari besarnya
# inventory sebelum di ubah. Jika lebih kecil ada beberapa item yang akan
# dihapus, namun item yang akan di hapus dapat di pilih setelahnya.
#
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
# Credit:
# Untuk buat ini memang ga sampai membuat saya berkeringat dingin atau masuk
# rumah sakit dan di opname. Tapi kalau memang kerjaan saya ini dipakai untuk
# projek kamu, tolong cantumkan nama saya (rusted_71) di bagian credit projek
# kamu.
#
# Thank to:
# modern_algebra
#
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
# Bug report or anything else:
# hubungi saya di
rusted_71@yahoo.co.id atau
# PM rusted_71 di
www.rpgmakerid.com atau
#
#==============================================================================
module RUSTED_ITEM
#==============================================================================
# *** EDITABLE SECTION
#==============================================================================
NONDISCARD = {0 => [31,25], #masukan id dari item2 yg nondiscardable
1 => [5,2], #masukan id dari weapon2 yg nondiscardable
2 => [1,2]} #masukan id dari armor2 yg nondiscardable
DEFAULT_MAX_SIZE = 10 #masukan besarnya inventory awal party
DEFAULT_ITEM_STACK = 99 #masukan jumlah batas max dari item
# STRING SECTION
PARTY_INV = "Party Inventory"
LOOT_INV = "Items to Discard"
USE_COM = "Use"
DIS_COM = "Discard"
#==============================================================================
# *** END of EDITABLE SECTION
#==============================================================================
end
#==============================================================================
# ** Game Actor
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# aliased method - equip
#==============================================================================
class Game_Actor < Game_Battler
alias new_equip equip
def equip(*args)
new_equip(*args)
if !$game_temp.slots_to_discard.slots.empty?
$game_temp.slots_to_discard.slots.reverse.each { |slot|
break unless $game_party.limit_inventory.enough_space? (slot)
item, type, id, n = slot.item, slot.item_type, slot.item_id, slot.amount
$game_party.gain_item(item, n)
$game_temp.slots_to_discard.remove_item (type, id, n)
}
end
end
end
#==============================================================================
# ** Game Actor
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# new public instance variables - slots_to_discard
#==============================================================================
class Game_Temp
alias new_initialize initialize
attr_accessor :slots_to_discard
def initialize
new_initialize
@slots_to_discard = Game_LimitedInventory.new(-1)
end
end
#==============================================================================
# ** Game Actor
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# new public instance variables - limit_inventory
# aliased method
# initialize
# gain_item
# gain_armor
# new method
# reduce_item
# gain_proses
#==============================================================================
class Game_Party
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Public Instance Variables
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
attr_reader :limit_inventory
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Aliased Method
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
alias new_initialize initialize
alias new_gain_item gain_item
alias new_gain_weapon gain_weapon
alias new_gain_armor gain_armor
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Object Initialization
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def initialize
new_initialize
@limit_inventory = Game_LimitedInventory.new (RUSTED_ITEM::DEFAULT_MAX_SIZE)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Gain Item (or Lose)
# item >> item / item_id
# n >> number
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def gain_item(item, n)
if item.is_a?(RPG::Item)
gain_proses(item, n)
id = item.id
elsif item.is_a?(RPG::Weapon)
gain_weapon(item.id, n)
elsif item.is_a?(RPG::Armor)
gain_armor(item.id, n)
else
gain_proses($data_items[item],n)
id = item
end
new_gain_item (id, n) if id != nil
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Gain Weapon And Armor (or Lose)
# item_id >> weapon / armor id
# n >> number
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def gain_weapon(item_id, n)
new_gain_weapon (item_id, n)
gain_proses($data_weapons[item_id],n)
end
def gain_armor(item_id, n)
new_gain_armor (item_id, n)
gain_proses($data_armors[item_id],n)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Reduce_Item (for synchronize default item number and limited item number)
# item >> item
# n >> number
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def reduce_item(item, n)
if item.is_a?(RPG::Item)
new_gain_item (item.id, -1*n)
elsif item.is_a?(RPG::Weapon)
new_gain_weapon (item.id, -1*n)
else
new_gain_armor (item.id, -1*n)
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Gain Proses
# item >> item
# n >> number
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def gain_proses(item,n)
if item != nil
type = item.is_a? (RPG::Item) ? 0 : item.is_a? (RPG::Weapon) ? 1 : 2
if n > 0
n2 = @limit_inventory.add_item (type, item.id, n)
n -= n2
if RUSTED_ITEM::NONDISCARD[type].include?(item.id)
while n2 > 0
for i in
0...@limit_inventory.slots.size
x = @limit_inventory.slots.size - 1 - i
slot = @limit_inventory.slots[x]
if !RUSTED_ITEM::NONDISCARD[slot.item_type].include?(slot.item_id)
l_type, id = slot.item_type, slot.item_id
while l_type == slot.item_type && id == slot.item_id
x -= 1
slot = @limit_inventory.slots[x]
end
l_item, l_n = @limit_inventory.slots[x + 1].item, @limit_inventory.slots[x + 1].amount
break
end
end
gain_proses(l_item, -1*l_n)
$game_temp.slots_to_discard.add_item (l_type, id, l_n)
n3 = @limit_inventory.add_item (type, item.id, n2)
n -= n3
n2 = n3
end
end
else
n2 = @limit_inventory.remove_item (type, item.id, -1*n)
n += n2
n2 *= -1
end
end
return if item == nil
if n2 > 0
$game_temp.slots_to_discard.add_item (type, item.id, n2)
elsif n2 < 0
$game_temp.slots_to_discard.remove_item (type, item.id, -1*n2)
end
end
end
#==============================================================================
# ** Interpreter
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# aliased method - command end
# new method - resize_inventory
#==============================================================================
class Interpreter
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Resize Inventory (change inventory size)
# new_size >> Number
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def resize_inventory (new_size)
$game_party.limit_inventory.resize (new_size)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Command End
# If there are items in $game_temp, open up the loot management
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
alias new_command_end command_end
def command_end
new_command_end
unless $game_temp.slots_to_discard.slots.empty?
$scene = Scene_Loot.new
end
end
end
#==============================================================================
# ** Scene Equip
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# aliased method - main
#==============================================================================
class Scene_Equip
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Main
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
alias new_main main
def main
new_main
$scene = Scene_Loot.new if !$game_temp.slots_to_discard.slots.empty?
end
end
#==============================================================================
# ** Scene Battle
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# aliased method - battle_end
#==============================================================================
class Scene_Battle
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * battle_end
# open up loot management if inventory is full in the end of battle
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
alias new_battle_end battle_end
def battle_end(result)
new_battle_end (result)
if !$game_temp.slots_to_discard.slots.empty? && !$scene.is_a? (Scene_Gameover)
$scene = Scene_Loot.new
end
end
end
#==============================================================================
# ** Game LimInvSlot
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# This class holds the data on a single slot of the inventory
#==============================================================================
class Game_LimInvSlot
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Public Instance Variables
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
attr_reader :item_type
attr_reader :item_id
attr_reader :amount
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Object Initialization
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def initialize
@item_type = -1
@item_id = 0
@amount = 0
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Add Item
# n >> the amount to add
# item_type >> the type of item being added
# item_id >> the ID of item being added
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def add_item (n, item_type = -1, item_id = 0)
if item_type != -1
@item_type = item_type
@item_id = item_id
end
x = space_left
if n > x
@amount += x
return n - x
else
@amount += n
return 0
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Remove Item
# n >> the amount to remove
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def remove_item (n)
@amount -= n
if @amount <= 0
n = -1*@amount
@item_type = -1
@item_id = 0
@amount = 0
return n
end
return 0
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Item
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def item
return case @item_type
when -1 then nil
when 0 then $data_items[@item_id]
when 1 then $data_weapons[@item_id]
when 2 then $data_armors[@item_id]
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Space Left
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def space_left
return 1 if item == nil
return RUSTED_ITEM::DEFAULT_ITEM_STACK - @amount if item.is_a?(RPG::Item)
return 1 - @amount
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Equal?
# other : another Game_LimInvSlot
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def == (other)
return false if !other.is_a? (Game_LimInvSlot)
return false if other.item_type != @item_type
return false if other.item_id != @item_id
return false if other.amount != @amount
return super (other)
end
end
#==============================================================================
# ** Game_LimitedInventory
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# This is an array to store the party's inventory
#==============================================================================
class Game_LimitedInventory
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Public Instance Variable
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
attr_reader :max_size
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Object Initialization
# size : the number of slots available
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def initialize (size)
@max_size = size
clear
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Clear
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def clear
@items = []
@weapons = []
@armors = []
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Resize
# size : the number of slots available
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def resize (size)
old_size = slots.size
if size < old_size
index = slots.size - 1
while slots.size > size
slot = slots[index]
if !RUSTED_ITEM::NONDISCARD[slot.item_type].include?(slot.item_id)
type, id, n = slot.item_type, slot.item_id, slot.amount
remove_item (type, id, n)
$game_temp.slots_to_discard.add_item (type, id, n)
index -= 1
else
index -= 1
end
break if index < 0
end
end
@max_size = size
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Add Item
# type : the type of item being added
# id : the ID of item being added
# n : the amount to add
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def add_item (type, id, n = 1)
array = case type
when 0 then @items
when 1 then @weapons
when 2 then @armors
end
sort_index = 0
array.each { |slot|
if slot.item_id == id
n = slot.add_item (n, type, id)
break if n == 0
sort_index += 1
elsif slot.item_id < id
sort_index += 1
else
break
end
}
if n > 0
while @max_size == -1 || ((@items.size + @weapons.size + @armors.size) < @max_size)
slot = Game_LimInvSlot.new
n = slot.add_item (n, type, id)
array.insert (sort_index, slot)
sort_index += 1
break if n == 0
end
end
return n
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Remove Item
# type : the type of item being removed
# id : the ID of item being removed
# n : the amount to remove
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def remove_item (type, id, n = 1)
array = case type
when 0 then @items
when 1 then @weapons
when 2 then @armors
end
array.reverse.each { |slot|
if slot.item_type == type && slot.item_id == id
n = slot.remove_item (n)
array.delete (slot) if slot.amount == 0
break if n == 0
end
}
return n
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Slots
# get all slot in the inventory
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def slots
return @items + @weapons + @armors
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * slot
# get slot for the certain item
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def slot(item)
array = @items
array = @weapons if item.is_a?(RPG::Weapon)
array = @armors if item.is_a?(RPG::Armor)
for i in 0... array.size
slot = array[i]
break if slot.item_id == item.id
end
return slot
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Check Space
# slot : an Game_InvSlot object
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def enough_space? (slot)
return true if @max_size == -1 || slots.size < @max_size
array = [@items, @weapons, @armors][slot.item_type]
array.each { |i|
if i.item_id > slot.item_id
break
elsif i.item_id == slot.item_id
x = slot.item.is_a?(RPG::Item) ? RUSTED_ITEM::DEFAULT_ITEM_STACK : 1
break if i.space_left == 0
return true if i.space_left < x
end
}
return false
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Equals?
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def == (other)
return false unless other.is_a? (Game_LimitedInventory)
return false if @max_size != other.max_size
return false if slots != other.slots
return super (other)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# * Cek Amount
# cek amount of an item in the inventory
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def cek_amount(type, id)
array = case type
when 0 then @items
when 1 then @weapons
when 2 then @armors
end
n = 0
array.each { |slot|
if slot.item_id == id
n += slot.amount
end
}
return n
end
end
#==============================================================================
# ** Window Item
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Summary of Changes:
# overwritten methods - initialize, item, refresh, draw_text
# new method - inventory
#==============================================================================
class Window_Item < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
# inventory >> an Game_LimitedInventory object
#--------------------------------------------------------------------------
def initialize(inventory = $game_party.limit_inventory)
super(0, 128, 320, 352)
@column_max = 1
@inventory = inventory
refresh
self.index = 0
if $game_temp.in_battle
self.y = 64
self.height = 256
self.back_opacity = 160
end
end
#--------------------------------------------------------------------------
# * Get Inventory
#--------------------------------------------------------------------------
def inventory
return @inventory
end
#--------------------------------------------------------------------------
# * Get Item
#--------------------------------------------------------------------------
def item
return nil if @data[self.index] == nil
return @data[self.index].item
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
# Add item
for slot in @inventory.slots
next if slot.item == nil
@data.push(slot)
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)
return if @data[index] == nil
item = @data[index].item
number = @data[index].amount
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
self.contents.font.color = normal_color if @inventory == $game_temp.slots_to_discard
x = 4
y = index * 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) if item.is_a?(RPG::Item)
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2) if item.is_a?(RPG::Item)
end
end
#==============================================================================
# ** Window Item Count
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Class for title of the inventory
#==============================================================================
class Window_Item_Count < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
# inventory >> an Game_LimitedInventory object
#--------------------------------------------------------------------------
def initialize(inventory)
super(0, 64, 320, 64)
@inventory = inventory
self.x = 320 if inventory == $game_temp.slots_to_discard
self.contents = Bitmap.new(width - 32, height - 32)
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
width = self.contents.width
if @inventory == $game_party.limit_inventory
self.contents.draw_text(0,0,width,32,RUSTED_ITEM::PARTY_INV)
self.contents.draw_text(0,0,width,32,@inventory.slots.size.to_s + " / " + @inventory.max_size.to_s,2)
else
self.contents.draw_text(0,0,width,32,RUSTED_ITEM::LOOT_INV)
end
end
end
#==============================================================================
# ** Window Item Target
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Class for target window in the Scene_Item
#==============================================================================
class Window_Item_Target < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(320, 64, 320, 416)
self.contents = Bitmap.new(width - 32, height - 32)
self.z += 10
@item_max = $game_party.actors.size
refresh
self.index = -2
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
for i in 0...$game_party.actors.size
x = 4
y = i * 96
actor = $game_party.actors[i]
draw_actor_name(actor, x, y)
draw_actor_class(actor, x + 144, y)
draw_actor_level(actor, x + 8, y + 32)
draw_actor_state(actor, x + 8, y + 64)
draw_actor_hp(actor, x + 144, y + 32)
draw_actor_sp(actor, x + 144, y + 64)
end
end
#--------------------------------------------------------------------------
# * Update Cursor Rect
#--------------------------------------------------------------------------
def update_cursor_rect
if @index <= -2
self.cursor_rect.set(0, (@index + 10) * 116, self.width - 28, 96)
elsif @index == -1
self.cursor_rect.set(0, 0, self.width - 28, @item_max * 96)
else
self.cursor_rect.set(0, @index * 96, self.width - 28, 96)
end
end
end
#==============================================================================
# ** Scene_Item
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# A new Scene_Item
#==============================================================================
class Scene_Item
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
@help_window = Window_Help.new
@item_window = Window_Item.new
@item_window.help_window = @help_window
@target_window = Window_Item_Target.new
@target_window.visible = true
@target_window.active = false
@mount_window = Window_Item_Count.new($game_party.limit_inventory)
@inv_com_window = Window_Command.new(96,[RUSTED_ITEM::USE_COM,RUSTED_ITEM::DIS_COM])
@inv_com_window.x = 200
@inv_com_window.active = false
@inv_com_window.visible = false
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@help_window.dispose
@inv_com_window.dispose
@item_window.dispose
@target_window.dispose
@mount_window.dispose
end
#--------------------------------------------------------------------------
# * Update Frame
#--------------------------------------------------------------------------
def update
@mount_window.update
@inv_com_window.update
@help_window.update
@item_window.update
@target_window.update
if @item_window.active
update_item
return
end
if @inv_com_window.active
update_command
return
end
if @target_window.active
update_target
return
end
end
#--------------------------------------------------------------------------
# * Update Item Window
#--------------------------------------------------------------------------
def update_item
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Menu.new(0)
return
end
if Input.trigger?(Input::C)
@item = @item_window.item
if @item != nil
@item_window.active = false
@inv_com_window.active = true
@inv_com_window.visible = true
@inv_com_window.y = 160 + @item_window.index * 32
else
$game_system.se_play($data_system.buzzer_se)
end
return
end
end
#--------------------------------------------------------------------------
# * Update Command Window
#--------------------------------------------------------------------------
def update_command
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@item_window.active = true
@inv_com_window.active = false
@inv_com_window.visible = false
return
end
if Input.trigger?(Input::C)
case @inv_com_window.index
when 0 then use_item
when 1 then discard_item
end
@inv_com_window.index = 0
return
end
end
#--------------------------------------------------------------------------
# * Discard Item Processing
#--------------------------------------------------------------------------
def discard_item
$game_system.se_play($data_system.decision_se)
slot = @item_window.inventory.slot(@item)
type, id, n = slot.item_type, slot.item_id, slot.amount
$game_party.reduce_item(@item, n)
$game_party.limit_inventory.remove_item (type, id, n)
@item_window.refresh
@mount_window.refresh
@item_window.active = true
@item_window.index -= 1 if @item_window.index != 0
@inv_com_window.active = false
@inv_com_window.visible = false
end
#--------------------------------------------------------------------------
# * Use Item Processing
#--------------------------------------------------------------------------
def use_item
unless @item.is_a?(RPG::Item)
$game_system.se_play($data_system.buzzer_se)
return
end
unless $game_party.item_can_use?(@item.id)
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
if @item.scope >= 3
@inv_com_window.active = false
@inv_com_window.visible = false
@target_window.visible = true
@target_window.active = true
if @item.scope == 4 || @item.scope == 6
@target_window.index = -1
else
@target_window.index = 0
end
else
if @item.common_event_id > 0
$game_temp.common_event_id = @item.common_event_id
$game_system.se_play(@item.menu_se)
if @item.consumable
$game_party.lose_item(@item.id, 1)
@item_window.draw_item(@item_window.index)
end
$scene = Scene_Map.new
return
end
end
end
end
#==============================================================================
# ** Scene_Loot
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Loot management scene
#==============================================================================
class Scene_Loot
#--------------------------------------------------------------------------
# * MainProcessing
#--------------------------------------------------------------------------
def main
@help_window = Window_Help.new
@item_window = Window_Item.new
@item_window.help_window = @help_window
@loot_window = Window_Item.new($game_temp.slots_to_discard)
@loot_window.active = false
@loot_window.x = 320
@loot_window.help_window = @help_window
@party_item_window = Window_Item_Count.new($game_party.limit_inventory)
@loot_item_window = Window_Item_Count.new($game_temp.slots_to_discard)
@loot_item_window.x = 320
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@help_window.dispose
@item_window.dispose
@loot_window.dispose
@party_item_window.dispose
@loot_item_window.dispose
end
#--------------------------------------------------------------------------
# * update Frame
#--------------------------------------------------------------------------
def update
@help_window.update
@item_window.update
@loot_window.update
@party_item_window.update
@loot_item_window.update
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
if !$game_temp.slots_to_discard.slots.empty?
$game_temp.slots_to_discard.slots.each { |slot|
$game_party.reduce_item(slot.item, slot.amount)
}
$game_temp.slots_to_discard.clear
end
$scene = Scene_Map.new
return
end
if @item_window.active
update_item
return
end
if @loot_window.active
update_loot
return
end
end
#--------------------------------------------------------------------------
# * Update Item Window
#--------------------------------------------------------------------------
def update_item
if Input.trigger?(Input::C)
item = @item_window.item
slot = @item_window.inventory.slot(item)
type, id, n = slot.item_type, slot.item_id, slot.amount
if !RUSTED_ITEM::NONDISCARD[type].include?(item.id)
$game_system.se_play($data_system.decision_se)
$game_party.limit_inventory.remove_item (type, id, n)
$game_temp.slots_to_discard.add_item(type, id, n)
else
$game_system.se_play($data_system.buzzer_se)
end
refresh
return
end
if Input.repeat?(Input::RIGHT)
@item_window.active = false
@loot_window.active = true
@loot_window.index = 0
@item_window.index = -1
return
end
end
#--------------------------------------------------------------------------
# * Update Loot Window
#--------------------------------------------------------------------------
def update_loot
if Input.trigger?(Input::C)
item = @loot_window.item
slot = @loot_window.inventory.slot(item)
type, id, n = slot.item_type, slot.item_id, slot.amount
if @item_window.inventory.enough_space? (slot)
$game_system.se_play($data_system.decision_se)
$game_party.gain_item (item, n)
$game_party.reduce_item(item, n)
$game_temp.slots_to_discard.remove_item(type, id, n)
else
$game_system.se_play($data_system.buzzer_se)
end
refresh
return
end
if Input.repeat?(Input::LEFT)
@item_window.active = true
@loot_window.active = false
@loot_window.index = -1
@item_window.index = 0
return
end
end
#--------------------------------------------------------------------------
# * Refresh Window
#--------------------------------------------------------------------------
def refresh
@item_window.refresh
@loot_window.refresh
@party_item_window.refresh
end
end
0 komentar:
Posting Komentar