mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-07 13:15:01 +00:00
392 lines
10 KiB
Ruby
392 lines
10 KiB
Ruby
#===============================================================================
|
|
# The Bag object, which actually contains all the items
|
|
#===============================================================================
|
|
class PokemonBag
|
|
attr_accessor :lastpocket
|
|
|
|
def self.pocketNames
|
|
return pbPocketNames
|
|
end
|
|
|
|
def self.numPockets
|
|
return self.pocketNames.length-1
|
|
end
|
|
|
|
def initialize
|
|
@lastpocket = 1
|
|
@pockets = []
|
|
@choices = []
|
|
for i in 0..PokemonBag.numPockets
|
|
@pockets[i] = []
|
|
@choices[i] = 0
|
|
end
|
|
@registeredItems = []
|
|
@registeredIndex = [0,0,1]
|
|
end
|
|
|
|
def rearrange
|
|
if (@pockets.length-1)!=PokemonBag.numPockets
|
|
newpockets = []
|
|
for i in 0..PokemonBag.numPockets
|
|
newpockets[i] = []
|
|
@choices[i] = 0 if !@choices[i]
|
|
end
|
|
nump = PokemonBag.numPockets
|
|
for i in 0...[@pockets.length,nump].min
|
|
for item in @pockets[i]
|
|
p = pbGetPocket(item[0])
|
|
newpockets[p].push(item)
|
|
end
|
|
end
|
|
@pockets = newpockets
|
|
end
|
|
end
|
|
|
|
def clear
|
|
for pocket in @pockets
|
|
pocket.clear
|
|
end
|
|
end
|
|
|
|
def pockets
|
|
rearrange
|
|
return @pockets
|
|
end
|
|
|
|
def maxPocketSize(pocket)
|
|
maxsize = BAG_MAX_POCKET_SIZE[pocket]
|
|
return -1 if !maxsize
|
|
return maxsize
|
|
end
|
|
|
|
# Gets the index of the current selected item in the pocket
|
|
def getChoice(pocket)
|
|
if pocket<=0 || pocket>PokemonBag.numPockets
|
|
raise ArgumentError.new(_INTL("Invalid pocket: {1}",pocket.inspect))
|
|
end
|
|
rearrange
|
|
return [@choices[pocket],@pockets[pocket].length].min || 0
|
|
end
|
|
|
|
# Sets the index of the current selected item in the pocket
|
|
def setChoice(pocket,value)
|
|
if pocket<=0 || pocket>PokemonBag.numPockets
|
|
raise ArgumentError.new(_INTL("Invalid pocket: {1}",pocket.inspect))
|
|
end
|
|
rearrange
|
|
@choices[pocket] = value if value<=@pockets[pocket].length
|
|
end
|
|
|
|
def getAllChoices
|
|
ret = @choices.clone
|
|
for i in 0...@choices.length; @choices[i] = 0; end
|
|
return ret
|
|
end
|
|
|
|
def setAllChoices(choices)
|
|
@choices = choices
|
|
end
|
|
|
|
def pbQuantity(item)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
pocket = pbGetPocket(item)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length if maxsize<0
|
|
return ItemStorageHelper.pbQuantity(@pockets[pocket],maxsize,item)
|
|
end
|
|
|
|
def pbHasItem?(item)
|
|
return pbQuantity(item)>0
|
|
end
|
|
|
|
def pbCanStore?(item,qty=1)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
pocket = pbGetPocket(item)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length+1 if maxsize<0
|
|
return ItemStorageHelper.pbCanStore?(@pockets[pocket],maxsize,
|
|
BAG_MAX_PER_SLOT,item,qty)
|
|
end
|
|
|
|
def pbStoreAllOrNone(item,qty=1)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
pocket = pbGetPocket(item)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length+1 if maxsize<0
|
|
return ItemStorageHelper.pbStoreAllOrNone(@pockets[pocket],maxsize,
|
|
BAG_MAX_PER_SLOT,item,qty)
|
|
end
|
|
|
|
def pbStoreItem(item,qty=1)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
pocket = pbGetPocket(item)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length+1 if maxsize<0
|
|
return ItemStorageHelper.pbStoreItem(@pockets[pocket],maxsize,
|
|
BAG_MAX_PER_SLOT,item,qty,true)
|
|
end
|
|
|
|
def pbChangeItem(olditem,newitem)
|
|
olditem = getID(PBItems,olditem)
|
|
newitem = getID(PBItems,newitem)
|
|
if !olditem || olditem<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",olditem))
|
|
elsif !newitem || newitem<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",newitem))
|
|
end
|
|
pocket = pbGetPocket(olditem)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length if maxsize<0
|
|
ret = false
|
|
for i in 0...maxsize
|
|
itemslot = @pockets[pocket][i]
|
|
if itemslot && itemslot[0]==olditem
|
|
itemslot[0] = newitem
|
|
ret = true
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
def pbChangeQuantity(pocket,index,newqty=1)
|
|
return false if pocket<=0 || pocket>self.numPockets
|
|
return false if @pockets[pocket].length<index
|
|
newqty = [newqty,maxPocketSize(pocket)].min
|
|
@pockets[pocket][index][1] = newqty
|
|
return true
|
|
end
|
|
|
|
def pbDeleteItem(item,qty=1)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
pocket = pbGetPocket(item)
|
|
maxsize = maxPocketSize(pocket)
|
|
maxsize = @pockets[pocket].length if maxsize<0
|
|
ret = ItemStorageHelper.pbDeleteItem(@pockets[pocket],maxsize,item,qty)
|
|
return ret
|
|
end
|
|
|
|
def registeredItems
|
|
@registeredItems = [] if !@registeredItems
|
|
if @registeredItem && @registeredItem>0 && !@registeredItems.include?(@registeredItem)
|
|
@registeredItems.push(@registeredItem)
|
|
@registeredItem = nil
|
|
end
|
|
return @registeredItems
|
|
end
|
|
|
|
def registeredItem; return registeredItems; end
|
|
|
|
def pbIsRegistered?(item)
|
|
registeredlist = self.registeredItems
|
|
return registeredlist.include?(item)
|
|
end
|
|
|
|
# Registers the item in the Ready Menu.
|
|
def pbRegisterItem(item)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
registeredlist = self.registeredItems
|
|
registeredlist.push(item) if !registeredlist.include?(item)
|
|
end
|
|
|
|
# Unregisters the item from the Ready Menu.
|
|
def pbUnregisterItem(item)
|
|
item = getID(PBItems,item)
|
|
if !item || item<1
|
|
raise ArgumentError.new(_INTL("Item number {1} is invalid.",item))
|
|
end
|
|
registeredlist = self.registeredItems
|
|
if registeredlist.include?(item)
|
|
for i in 0...registeredlist.length
|
|
next if registeredlist[i]!=item
|
|
registeredlist[i] = nil
|
|
break
|
|
end
|
|
registeredlist.compact!
|
|
end
|
|
end
|
|
|
|
def registeredIndex
|
|
@registeredIndex = [0,0,1] if !@registeredIndex
|
|
return @registeredIndex
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# The PC item storage object, which actually contains all the items
|
|
#===============================================================================
|
|
class PCItemStorage
|
|
MAXSIZE = 50 # Number of different slots in storage
|
|
MAXPERSLOT = 999 # Max. number of items per slot
|
|
|
|
def initialize
|
|
@items = []
|
|
# Start storage with a Potion
|
|
pbStoreItem(getConst(PBItems,:POTION)) if hasConst?(PBItems,:POTION)
|
|
end
|
|
|
|
def [](i)
|
|
@items[i]
|
|
end
|
|
|
|
def length
|
|
@items.length
|
|
end
|
|
|
|
def empty?
|
|
return @items.length==0
|
|
end
|
|
|
|
def clear
|
|
@items.clear
|
|
end
|
|
|
|
def getItem(index)
|
|
return (index<0 || index>=@items.length) ? 0 : @items[index][0]
|
|
end
|
|
|
|
def getCount(index)
|
|
return (index<0 || index>=@items.length) ? 0 : @items[index][1]
|
|
end
|
|
|
|
def pbQuantity(item)
|
|
return ItemStorageHelper.pbQuantity(@items,MAXSIZE,item)
|
|
end
|
|
|
|
def pbCanStore?(item,qty=1)
|
|
return ItemStorageHelper.pbCanStore?(@items,MAXSIZE,MAXPERSLOT,item,qty)
|
|
end
|
|
|
|
def pbStoreItem(item,qty=1)
|
|
return ItemStorageHelper.pbStoreItem(@items,MAXSIZE,MAXPERSLOT,item,qty)
|
|
end
|
|
|
|
def pbDeleteItem(item,qty=1)
|
|
return ItemStorageHelper.pbDeleteItem(@items,MAXSIZE,item,qty)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Implements methods that act on arrays of items. Each element in an item
|
|
# array is itself an array of [itemID, itemCount].
|
|
# Used by the Bag, PC item storage, and Triple Triad.
|
|
#===============================================================================
|
|
module ItemStorageHelper
|
|
# Returns the quantity of the given item in the items array, maximum size per
|
|
# slot, and item ID
|
|
def self.pbQuantity(items,maxsize,item)
|
|
ret = 0
|
|
for i in 0...maxsize
|
|
itemslot = items[i]
|
|
ret += itemslot[1] if itemslot && itemslot[0]==item
|
|
end
|
|
return ret
|
|
end
|
|
|
|
# Deletes an item (items array, max. size per slot, item, no. of items to delete)
|
|
def self.pbDeleteItem(items,maxsize,item,qty)
|
|
raise "Invalid value for qty: #{qty}" if qty<0
|
|
return true if qty==0
|
|
ret = false
|
|
for i in 0...maxsize
|
|
itemslot = items[i]
|
|
next if !itemslot || itemslot[0]!=item
|
|
amount = [qty,itemslot[1]].min
|
|
itemslot[1] -= amount
|
|
qty -= amount
|
|
items[i] = nil if itemslot[1]==0
|
|
next if qty>0
|
|
ret = true
|
|
break
|
|
end
|
|
items.compact!
|
|
return ret
|
|
end
|
|
|
|
def self.pbCanStore?(items,maxsize,maxPerSlot,item,qty)
|
|
raise "Invalid value for qty: #{qty}" if qty<0
|
|
return true if qty==0
|
|
for i in 0...maxsize
|
|
itemslot = items[i]
|
|
if !itemslot
|
|
qty -= [qty,maxPerSlot].min
|
|
return true if qty==0
|
|
elsif itemslot[0]==item && itemslot[1]<maxPerSlot
|
|
newamt = itemslot[1]
|
|
newamt = [newamt+qty,maxPerSlot].min
|
|
qty -= (newamt-itemslot[1])
|
|
return true if qty==0
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
def self.pbStoreItem(items,maxsize,maxPerSlot,item,qty,sorting=false)
|
|
raise "Invalid value for qty: #{qty}" if qty<0
|
|
return true if qty==0
|
|
itemPocket = pbGetPocket(item)
|
|
for i in 0...maxsize
|
|
itemslot = items[i]
|
|
if !itemslot
|
|
items[i] = [item,[qty,maxPerSlot].min]
|
|
qty -= items[i][1]
|
|
items.sort! if sorting && BAG_POCKET_AUTO_SORT[itemPocket]
|
|
return true if qty==0
|
|
elsif itemslot[0]==item && itemslot[1]<maxPerSlot
|
|
newamt = itemslot[1]
|
|
newamt = [newamt+qty,maxPerSlot].min
|
|
qty -= (newamt-itemslot[1])
|
|
itemslot[1] = newamt
|
|
return true if qty==0
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Shortcut methods
|
|
#===============================================================================
|
|
def pbQuantity(*args)
|
|
return $PokemonBag.pbQuantity(*args)
|
|
end
|
|
|
|
def pbHasItem?(*args)
|
|
return $PokemonBag.pbHasItem?(*args)
|
|
end
|
|
|
|
def pbCanStore?(*args)
|
|
return $PokemonBag.pbCanStore?(*args)
|
|
end
|
|
|
|
def pbStoreItem(*args)
|
|
return $PokemonBag.pbStoreItem(*args)
|
|
end
|
|
|
|
def pbStoreAllOrNone(*args)
|
|
return $PokemonBag.pbStoreAllOrNone(*args)
|
|
end
|