Release 0.0.1.8.8.7
This commit is contained in:
1 parent
3c8a17aa78
commit
c7beab414c
16283 files changed
+768761
-2
No files matched your search
@@ -0,0 +1,855 @@
|
||||
#==============================================================================
|
||||
# This script has been altered by Kslander for the need of LonaRPG
|
||||
#==============================================================================
|
||||
#==============================================================================
|
||||
# ** Game_Party
|
||||
#------------------------------------------------------------------------------
|
||||
# This class handles parties. Information such as gold and items is included.
|
||||
# Instances of this class are referenced by $game_party.
|
||||
#==============================================================================
|
||||
|
||||
class Game_Party < Game_Unit
|
||||
#--------------------------------------------------------------------------
|
||||
# * Constants
|
||||
#--------------------------------------------------------------------------
|
||||
ABILITY_ENCOUNTER_HALF = 0 # halve encounters
|
||||
ABILITY_ENCOUNTER_NONE = 1 # disable encounters
|
||||
ABILITY_CANCEL_SURPRISE = 2 # disable surprise
|
||||
ABILITY_RAISE_PREEMPTIVE = 3 # increase preemptive strike rate
|
||||
ABILITY_GOLD_DOUBLE = 4 # double money earned
|
||||
ABILITY_DROP_ITEM_DOUBLE = 5 # double item acquisition rate
|
||||
#--------------------------------------------------------------------------
|
||||
# * Public Instance Variables
|
||||
#--------------------------------------------------------------------------
|
||||
attr_reader :gold # party's gold
|
||||
attr_reader :steps # number of steps
|
||||
attr_reader :last_item # for cursor memorization: item
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super
|
||||
@gold = 0
|
||||
@steps = 0
|
||||
@last_item = Game_BaseItem.new
|
||||
@menu_actor_id = 0
|
||||
@target_actor_id = 0
|
||||
@actors = []
|
||||
init_all_items
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Initialize All Item Lists
|
||||
#--------------------------------------------------------------------------
|
||||
def init_all_items
|
||||
@items = {}
|
||||
@weapons = {}
|
||||
@armors = {}
|
||||
end
|
||||
|
||||
def get_items
|
||||
@items
|
||||
end
|
||||
def get_weapons
|
||||
@weapons
|
||||
end
|
||||
def get_armors
|
||||
@armors
|
||||
end
|
||||
|
||||
|
||||
def set_items(tmpItems)
|
||||
@items = tmpItems
|
||||
end
|
||||
def set_weapons(tmpWeapons)
|
||||
@weapons = tmpWeapons
|
||||
end
|
||||
def set_armors(tmpArmors)
|
||||
@armors = tmpArmors
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine Existence
|
||||
#--------------------------------------------------------------------------
|
||||
def exists
|
||||
!@actors.empty?
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Members
|
||||
#--------------------------------------------------------------------------
|
||||
def members
|
||||
in_battle ? battle_members : all_members
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get All Members
|
||||
#--------------------------------------------------------------------------
|
||||
def all_members
|
||||
@actors.collect {|id| $game_actors[id] }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Battle Members
|
||||
#--------------------------------------------------------------------------
|
||||
def battle_members
|
||||
all_members[0, max_battle_members].select {|actor| actor.exist? }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Maximum Number of Battle Members
|
||||
#--------------------------------------------------------------------------
|
||||
def max_battle_members
|
||||
return 4
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Leader
|
||||
#--------------------------------------------------------------------------
|
||||
def leader
|
||||
battle_members[0]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Item Object Array
|
||||
#--------------------------------------------------------------------------
|
||||
def items
|
||||
@items.keys.sort.collect {|id| $data_items[id] }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Weapon Object Array
|
||||
#--------------------------------------------------------------------------
|
||||
def weapons
|
||||
@weapons.keys.sort.collect {|id| $data_weapons[id] }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Armor Object Array
|
||||
#--------------------------------------------------------------------------
|
||||
def armors
|
||||
@armors.keys.sort.collect {|id| $data_armors[id] }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Array of All Equipment Objects
|
||||
#--------------------------------------------------------------------------
|
||||
def equip_items
|
||||
weapons + armors
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Array of All Item Objects
|
||||
#--------------------------------------------------------------------------
|
||||
def all_items
|
||||
items + equip_items
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Container Object Corresponding to Item Class
|
||||
#--------------------------------------------------------------------------
|
||||
def item_container(item_class)
|
||||
return @items if item_class == RPG::Item
|
||||
return @weapons if item_class == RPG::Weapon
|
||||
return @armors if item_class == RPG::Armor
|
||||
return nil
|
||||
end
|
||||
def normalize_party_item(item)
|
||||
item = $data_ItemName[item] if item.is_a?(String)
|
||||
item = item.object if defined?(Game_BaseItem) && item.is_a?(Game_BaseItem)
|
||||
item
|
||||
rescue
|
||||
nil
|
||||
end
|
||||
def item_container_for_object(item)
|
||||
return @items if item.is_a?(RPG::Item)
|
||||
return @weapons if item.is_a?(RPG::Weapon)
|
||||
return @armors if item.is_a?(RPG::Armor)
|
||||
return nil
|
||||
rescue
|
||||
nil
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Initial Party Setup
|
||||
#--------------------------------------------------------------------------
|
||||
def setup_starting_members
|
||||
@actors = $data_system.party_members.clone
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Party Name
|
||||
# If there is only one, returns the actor's name.
|
||||
# If there are more, returns "XX's Party".
|
||||
#--------------------------------------------------------------------------
|
||||
def name
|
||||
return "" if battle_members.size == 0
|
||||
return leader.name if battle_members.size == 1
|
||||
return sprintf(Vocab::PartyName, leader.name)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Up Battle Test
|
||||
#--------------------------------------------------------------------------
|
||||
def setup_battle_test
|
||||
setup_battle_test_members
|
||||
setup_battle_test_items
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Highest Level of Party Members
|
||||
#--------------------------------------------------------------------------
|
||||
def highest_level
|
||||
lv = members.collect {|actor| actor.level }.max
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Add an Actor
|
||||
#--------------------------------------------------------------------------
|
||||
def add_actor(actor_id)
|
||||
@actors.push(actor_id) unless @actors.include?(actor_id)
|
||||
$game_player.refresh
|
||||
$game_map.need_refresh = true
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Remove Actor
|
||||
#--------------------------------------------------------------------------
|
||||
def remove_actor(actor_id)
|
||||
@actors.delete(actor_id)
|
||||
$game_player.refresh
|
||||
$game_map.need_refresh = true
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Increase Gold
|
||||
#--------------------------------------------------------------------------
|
||||
def gain_gold(amount)
|
||||
$story_stats["record_TotalGain_TP"] += amount
|
||||
@gold = [[@gold + amount, 0].max, max_gold].min
|
||||
end
|
||||
def set_gold(amount) #use in storage box
|
||||
$story_stats["record_TotalGain_TP"] += amount
|
||||
@gold = amount
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Decrease Gold
|
||||
#--------------------------------------------------------------------------
|
||||
def lose_gold(amount)
|
||||
gain_gold(-amount)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Maximum Value of Gold
|
||||
#--------------------------------------------------------------------------
|
||||
def max_gold
|
||||
return 99999999
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Increase Steps
|
||||
#--------------------------------------------------------------------------
|
||||
def increase_steps
|
||||
@steps += 1
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Number of Items Possessed
|
||||
#--------------------------------------------------------------------------
|
||||
def item_number(item)
|
||||
item = normalize_party_item(item)
|
||||
return 0 if item.nil?
|
||||
container = item_container_for_object(item)
|
||||
container ? container[item.id.to_i] || 0 : 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Maximum Number of Items Possessed
|
||||
#--------------------------------------------------------------------------
|
||||
def max_item_number(item)
|
||||
return 65534
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine if Maximum Number of Items Are Possessed
|
||||
#--------------------------------------------------------------------------
|
||||
def item_max?(item)
|
||||
item_number(item) >= max_item_number(item)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine Item Possession Status
|
||||
# include_equip : Include equipped items
|
||||
#--------------------------------------------------------------------------
|
||||
def has_item?(item, include_equip = false)
|
||||
item = normalize_party_item(item)
|
||||
return false if item.nil?
|
||||
return true if item_number(item) > 0
|
||||
return include_equip ? members_equip_include?(item) : false
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine if Specified Item Is Included in Members' Equipment
|
||||
#--------------------------------------------------------------------------
|
||||
def members_equip_include?(item)
|
||||
members.any? {|actor| actor.equips.include?(item) }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Increase/Decrease Items
|
||||
# include_equip : Include equipped items
|
||||
#--------------------------------------------------------------------------
|
||||
#def item_container(item_class)
|
||||
# return @items if item_class == RPG::Item
|
||||
# return @weapons if item_class == RPG::Weapon
|
||||
# return @armors if item_class == RPG::Armor
|
||||
# return nil
|
||||
#end
|
||||
def gain_item_core(item, amount=1, include_equip = false)
|
||||
item = normalize_party_item(item)
|
||||
return if item.nil?
|
||||
container = item_container_for_object(item)
|
||||
return unless container
|
||||
last_number = item_number(item)
|
||||
new_number = last_number + amount
|
||||
item_id = item.id.to_i
|
||||
container[item_id] = [[new_number, 0].max, max_item_number(item)].min
|
||||
container.delete(item_id) if container[item_id] == 0
|
||||
if include_equip && new_number < 0
|
||||
discard_members_equip(item, -new_number)
|
||||
end
|
||||
end
|
||||
def gain_item(item, amount=1, include_equip = false)
|
||||
gain_item_core(item, amount, include_equip)
|
||||
refresh_ext_item
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Discard Members' Equipment
|
||||
#--------------------------------------------------------------------------
|
||||
def discard_members_equip(item, amount)
|
||||
n = amount
|
||||
members.each do |actor|
|
||||
while n > 0 && actor.equips.include?(item)
|
||||
actor.discard_equip(item)
|
||||
n -= 1
|
||||
end
|
||||
end
|
||||
$game_actors[1].calculate_weight_carried #更新負重量數字
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Lose Items
|
||||
# include_equip : Include equipped items
|
||||
#--------------------------------------------------------------------------
|
||||
def lose_item(item, amount=1, include_equip = false)
|
||||
gain_item(item, -amount, include_equip)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Consume Items
|
||||
# If the specified object is a consumable item, the number in investory
|
||||
# will be reduced by 1.
|
||||
#--------------------------------------------------------------------------
|
||||
def consume_item(item)
|
||||
lose_item(item, 1) if item.consumable && !item.key_item?
|
||||
#lose_item(item, 1) if item.is_a?(RPG::Item) && item.consumable #original
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine Skill/Item Usability
|
||||
#--------------------------------------------------------------------------
|
||||
def usable?(item)
|
||||
members.any? {|actor| actor.usable?(item) }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine Command Inputability During Battle
|
||||
#--------------------------------------------------------------------------
|
||||
#def inputable?
|
||||
# members.any? {|actor| actor.inputable? }
|
||||
#end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine if Everyone is Dead
|
||||
#--------------------------------------------------------------------------
|
||||
def all_dead?
|
||||
super && ($game_party.in_battle || members.size > 0)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Processing Performed When Player Takes 1 Step
|
||||
#--------------------------------------------------------------------------
|
||||
def on_player_walk
|
||||
members.each {|actor| actor.on_player_walk }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Actor Selected on Menu Screen
|
||||
#--------------------------------------------------------------------------
|
||||
def menu_actor
|
||||
$game_actors[@menu_actor_id] || members[0]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Actor Selected on Menu Screen
|
||||
#--------------------------------------------------------------------------
|
||||
def menu_actor=(actor)
|
||||
@menu_actor_id = actor.id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Select Next Actor on Menu Screen
|
||||
#--------------------------------------------------------------------------
|
||||
def menu_actor_next
|
||||
index = members.index(menu_actor) || -1
|
||||
index = (index + 1) % members.size
|
||||
self.menu_actor = members[index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Select Previous Actor on Menu Screen
|
||||
#--------------------------------------------------------------------------
|
||||
def menu_actor_prev
|
||||
index = members.index(menu_actor) || 1
|
||||
index = (index + members.size - 1) % members.size
|
||||
self.menu_actor = members[index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Actor Targeted by Skill/Item Use
|
||||
#--------------------------------------------------------------------------
|
||||
def target_actor
|
||||
$game_actors[@target_actor_id] || members[0]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Actor Targeted by Skill/Item Use
|
||||
#--------------------------------------------------------------------------
|
||||
def target_actor=(actor)
|
||||
@target_actor_id = actor.id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Change Order
|
||||
#--------------------------------------------------------------------------
|
||||
def swap_order(index1, index2)
|
||||
@actors[index1], @actors[index2] = @actors[index2], @actors[index1]
|
||||
$game_player.refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Character Image Information for Save File Display
|
||||
#--------------------------------------------------------------------------
|
||||
def characters_for_savefile
|
||||
battle_members.collect do |actor|
|
||||
[actor.character_name, actor.character_index]
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine Party Ability
|
||||
#--------------------------------------------------------------------------
|
||||
def party_ability(ability_id)
|
||||
battle_members.any? {|actor| actor.party_ability(ability_id) }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Halve Encounters?
|
||||
#--------------------------------------------------------------------------
|
||||
def encounter_half?
|
||||
party_ability(ABILITY_ENCOUNTER_HALF)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Disable Encounters?
|
||||
#--------------------------------------------------------------------------
|
||||
def encounter_none?
|
||||
party_ability(ABILITY_ENCOUNTER_NONE)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Disable Surprise?
|
||||
#--------------------------------------------------------------------------
|
||||
def cancel_surprise?
|
||||
party_ability(ABILITY_CANCEL_SURPRISE)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Increase Preemptive Strike Rate?
|
||||
#--------------------------------------------------------------------------
|
||||
def raise_preemptive?
|
||||
party_ability(ABILITY_RAISE_PREEMPTIVE)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Double Money Earned?
|
||||
#--------------------------------------------------------------------------
|
||||
def gold_double?
|
||||
party_ability(ABILITY_GOLD_DOUBLE)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Double Item Acquisition Rate?
|
||||
#--------------------------------------------------------------------------
|
||||
def drop_item_double?
|
||||
party_ability(ABILITY_DROP_ITEM_DOUBLE)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Calculate Probability of Preemptive Attack
|
||||
#--------------------------------------------------------------------------
|
||||
def rate_preemptive(troop_agi)
|
||||
(agi >= troop_agi ? 0.05 : 0.03) * (raise_preemptive? ? 4 : 1)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Calculate Probability of Surprise
|
||||
#--------------------------------------------------------------------------
|
||||
def rate_surprise(troop_agi)
|
||||
cancel_surprise? ? 0 : (agi >= troop_agi ? 0.03 : 0.05)
|
||||
end
|
||||
|
||||
def gain_items_by_price(cur_vol=1,good=["ItemCoin1","ItemCoin2","ItemCoin3"],summon=false) #以價格為基準取得DATA ITEMS 物品價格建議由高至低
|
||||
cur_vol = 1 if cur_vol < 1
|
||||
cur_vol = cur_vol.round
|
||||
item_list = Array.new
|
||||
tmpResultReport = Array.new
|
||||
good.each do |comp_item|
|
||||
item_list.push($data_ItemName[comp_item])
|
||||
end
|
||||
item_list.sort_by!{| obj | obj.price}
|
||||
item_list.reverse!
|
||||
total_vol = cur_vol
|
||||
item_list.each do |tar_item|
|
||||
item_price = tar_item.price
|
||||
next if cur_vol < item_price || item_price == nil || item_price == 0
|
||||
item_num = cur_vol / item_price
|
||||
next if item_num < 1
|
||||
cur_vol -= item_price * item_num
|
||||
if summon == false
|
||||
item_num = item_num.to_i
|
||||
gain_item(tar_item,item_num)
|
||||
tmpResultReport << [tar_item.icon_index,item_num]
|
||||
else
|
||||
item_num = item_num.to_i
|
||||
temp_loop = 0
|
||||
until temp_loop == item_num
|
||||
temp_loop +=1
|
||||
$game_map.reserve_summon_event(tar_item.item_name,$game_player.x,$game_player.y,-1,{:user=>$game_player})
|
||||
end
|
||||
end
|
||||
end
|
||||
cur_vol = cur_vol.to_i
|
||||
if cur_vol > 0
|
||||
gain_gold(cur_vol)
|
||||
tmpResultReport << [261,cur_vol]
|
||||
end
|
||||
tmpResultReport
|
||||
end
|
||||
|
||||
def force_use_item_type(type_name)
|
||||
operation_tar_type=type_name
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(operation_tar_type)
|
||||
tmpDisplayItem = item
|
||||
tmpDisplayItemNum = item_number(tmpDisplayItem)
|
||||
item_number(item).times {
|
||||
$game_player.actor.itemUseBatch(item)
|
||||
}
|
||||
$game_map.popup(0,"-#{tmpDisplayItemNum}",tmpDisplayItem.icon_index,-1)
|
||||
}
|
||||
end
|
||||
|
||||
|
||||
def has_item_type(type_name)
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(type_name)
|
||||
amt=item_number(item)
|
||||
for i in 0...amt
|
||||
temp_val += item_number(item)
|
||||
end
|
||||
}
|
||||
return false if temp_val == 0
|
||||
return true if temp_val > 0
|
||||
end
|
||||
|
||||
def item_type_HowMany(type_name)
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(type_name)
|
||||
amt=item_number(item)
|
||||
for i in 0...amt
|
||||
temp_val += 1
|
||||
end
|
||||
}
|
||||
temp_val
|
||||
end
|
||||
|
||||
def item_tag_HowMany(type_name)
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type_tag.eql?(type_name)
|
||||
amt=item_number(item)
|
||||
for i in 0...amt
|
||||
temp_val += 1
|
||||
end
|
||||
}
|
||||
temp_val
|
||||
end
|
||||
|
||||
|
||||
def item_has_common_tag_and_report(tarData)
|
||||
temp_val=0
|
||||
all_items.any?{
|
||||
|item|
|
||||
next unless item.common_tags
|
||||
next unless item.common_tags[tarData]
|
||||
temp_val = item.common_tags[tarData]
|
||||
}
|
||||
temp_val
|
||||
end
|
||||
|
||||
|
||||
def item_PotData_HowMany(tarData)
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next unless item.pot_data
|
||||
next unless item.pot_data[tarData]
|
||||
amt=item_number(item)*item.pot_data[tarData].to_i
|
||||
for i in 0...amt
|
||||
temp_val += 1
|
||||
end
|
||||
}
|
||||
temp_val
|
||||
end
|
||||
|
||||
def decrease_item_type(type_name,tmpNum)
|
||||
temp_val=0
|
||||
all_items.any?{
|
||||
|item|
|
||||
next if item.type != type_name
|
||||
lose_item(item,tmpNum,true)
|
||||
return
|
||||
}
|
||||
end
|
||||
|
||||
def get_item_type_price(type_name)
|
||||
operation_tar_type=type_name
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(operation_tar_type)
|
||||
amt=item_number(item)
|
||||
for i in 0...amt
|
||||
temp_val += item.price
|
||||
end
|
||||
}
|
||||
return temp_val
|
||||
end
|
||||
|
||||
def get_item_type_to_array(type_name)
|
||||
operation_tar_type=type_name
|
||||
temp_val=[]
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(operation_tar_type)
|
||||
amt=item_number(item)
|
||||
for i in 0...amt
|
||||
temp_val.push(item)
|
||||
end
|
||||
}
|
||||
return temp_val
|
||||
end
|
||||
|
||||
def lost_item_type(type_name)
|
||||
operation_tar_type=type_name
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type.eql?(operation_tar_type)
|
||||
amt=item_number(item)
|
||||
lose_item(item,item_number(item),true)
|
||||
}
|
||||
end
|
||||
|
||||
def lost_item_tag(type_name)
|
||||
operation_tar_type=type_name
|
||||
temp_val=0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.type_tag.eql?(operation_tar_type)
|
||||
amt=item_number(item)
|
||||
lose_item(item,item_number(item),true)
|
||||
}
|
||||
end
|
||||
|
||||
def lost_humanoid_baby
|
||||
tmpBBcount = 0
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !item.common_tags["baby_LonaHumChild"]
|
||||
amt=item_number(item)
|
||||
data = "Rebirth_Lost_#{item.item_name}"
|
||||
p "lostBaby from $game_party.lost_humanoid_baby => #{data}"
|
||||
$story_stats[data] += 1
|
||||
lose_item(item,item_number(item),true)
|
||||
$story_stats["dialog_baby_lost"] =1
|
||||
$story_stats["sex_record_birth_BabyLost"] += amt
|
||||
tmpBBcount += amt
|
||||
}
|
||||
tmpBBcount
|
||||
end
|
||||
|
||||
def drop_item_and_summon(itemid,amt=1)
|
||||
return if item_number($data_items[itemid])==0
|
||||
lose_item($data_items[itemid],amt)
|
||||
$game_temp.call_item_drop([$data_items[itemid].item_name])
|
||||
end
|
||||
|
||||
def drop_items_of_type_and_summon(type)
|
||||
dropped_item=Array.new
|
||||
members.each do |actor|
|
||||
eqps=actor.equips
|
||||
eqps.each{
|
||||
|eqp|
|
||||
next if eqp.nil? || !type.eql?(eqp.type_tag)
|
||||
actor.discard_equip(eqp)
|
||||
amt=item_number(eqp)+1
|
||||
dropped_item.concat(Array.new(amt,eqp.item_name))
|
||||
lose_item(eqp,amt,true)
|
||||
}
|
||||
all_items.each{
|
||||
|item|
|
||||
next if !type.eql?(item.type_tag)
|
||||
amt=item_number(item)
|
||||
lose_item(item,item_number(item),true)
|
||||
dropped_item.concat(Array.new(amt,item.item_name))
|
||||
}
|
||||
$game_temp.call_item_drop(dropped_item)
|
||||
end
|
||||
end
|
||||
|
||||
def drop_all_equipped_items_and_summon(except=["Key","Bondage","Hair","Trait", "Child"])
|
||||
dropped_item=Array.new
|
||||
members.each do |actor|
|
||||
eqps=actor.equips
|
||||
eqps.each{
|
||||
|eqp|
|
||||
next if eqp.nil? || except.include?(eqp.type_tag) || eqp.key_item?
|
||||
actor.discard_equip(eqp)
|
||||
amt=item_number(eqp)+1
|
||||
dropped_item.concat(Array.new(amt,eqp.item_name))
|
||||
lose_item(eqp,amt,true)
|
||||
}
|
||||
$game_temp.call_item_drop(dropped_item)
|
||||
$game_player.actor.update_chs
|
||||
$game_player.actor.portrait.update
|
||||
$game_player.refresh_chs #was only scheduling refresh, but not executing it, so caused wrong spreadsheet until first update.
|
||||
end
|
||||
end
|
||||
|
||||
#掉落除了指定Tag(except)以外的物品
|
||||
def drop_items_and_summon(except,summon=true,tmpRngAMT=false)
|
||||
dropped_item=Array.new
|
||||
all_items.each{
|
||||
|item|
|
||||
p "except.include?(#{item.type_tag})=> #{except.include?(item.type_tag)}"
|
||||
next if except.include?(item.type_tag) || item.key_item?
|
||||
amt=item_number(item)
|
||||
amt = rand(amt) if tmpRngAMT
|
||||
lose_item(item,amt,true) if amt > 0
|
||||
dropped_item.concat(Array.new(amt,item.item_name)) if amt > 0
|
||||
}
|
||||
$game_temp.call_item_drop(dropped_item) if summon==true
|
||||
end
|
||||
|
||||
def drop_all_equipped_items_to_storage(storageID=65535,except=["Key","Bondage","Hair","Trait", "Child"], skipfrist=false)
|
||||
dropped_item=Array.new
|
||||
members.each do |actor|
|
||||
eqps=actor.equips
|
||||
eqps.each{
|
||||
|eqp|
|
||||
next if eqp.nil? || except.include?(eqp.type_tag) || eqp.key_item?
|
||||
actor.discard_equip(eqp)
|
||||
amt=item_number(eqp)+1
|
||||
if amt >= 2 && skipfrist #skip frist item
|
||||
amt -= 1
|
||||
lose_item(eqp,1,true)
|
||||
elsif amt == 1 && skipfrist && rand(100) > 60
|
||||
next lose_item(eqp,amt,true)
|
||||
end
|
||||
|
||||
if !$game_boxes.box(storageID)[eqp]
|
||||
$game_boxes.box(storageID)[eqp] = amt
|
||||
else
|
||||
$game_boxes.box(storageID)[eqp] += amt
|
||||
end
|
||||
lose_item(eqp,amt,true)
|
||||
}
|
||||
$game_player.actor.update_chs
|
||||
$game_player.actor.portrait.update
|
||||
$game_player.refresh_chs #was only scheduling refresh, but not executing it, so caused wrong spreadsheet until first update.
|
||||
end
|
||||
end
|
||||
|
||||
def drop_items_to_storage(storageID=65535,except=[],skipfrist=false)
|
||||
dropped_item=Array.new
|
||||
all_items.each{
|
||||
|item|
|
||||
p "except.include?(#{item.type_tag})=> #{except.include?(item.type_tag)}"
|
||||
next if except.include?(item.type_tag) || item.key_item?
|
||||
amt=item_number(item)
|
||||
if amt >= 2 && skipfrist #skip frist item
|
||||
amt -= 1
|
||||
lose_item(item,1,true)
|
||||
elsif amt == 1 && skipfrist && rand(100) > 60
|
||||
next lose_item(item,amt,true)
|
||||
end
|
||||
if !$game_boxes.box(storageID)[item]
|
||||
$game_boxes.box(storageID)[item] = amt
|
||||
else
|
||||
$game_boxes.box(storageID)[item] += amt
|
||||
end
|
||||
lose_item(item,item_number(item),true)
|
||||
}
|
||||
end
|
||||
|
||||
def get_price_from_items(except=["Key","Bondage","Hair","Trait", "Child"])
|
||||
dropped_item=Array.new
|
||||
tarPrice= 0
|
||||
all_items.each{
|
||||
|item|
|
||||
p "except.include?(#{item.type_tag})=> #{except.include?(item.type_tag)}"
|
||||
next if except.include?(item.type_tag)
|
||||
amt=item_number(item)
|
||||
tarPrice += item.price*amt
|
||||
}
|
||||
tarPrice
|
||||
end
|
||||
|
||||
def drop_all_items_and_summon(include_equip=false,except=["Key","Bondage","Hair","Trait", "Child"],summon=true)
|
||||
p "drop_all_items_and_summon"
|
||||
p "drop_items_and_summon"
|
||||
drop_items_and_summon(except,summon)
|
||||
p "drop_all_equipped_items_and_summon"
|
||||
drop_all_equipped_items_and_summon(except) if include_equip
|
||||
end
|
||||
|
||||
#def drop_raw(tmpBasedOn=$game_date.dateAmt,rawList = ["RawSemen","RawWaste","RawMeat","RawPlant","RawMilk","RawSemen","RawOther"])
|
||||
# all_items.each{
|
||||
# |item|
|
||||
# next unless rawList.include?(item.type_tag)
|
||||
# next unless item.addData
|
||||
# item.raw_date ? tmpDropAMT = item.raw_date : tmpDropAMT = 1
|
||||
# if tmpBasedOn % tmpDropAMT == 0
|
||||
# amt = 1+rand(item_number(item))
|
||||
# next lose_item(item,amt,true)
|
||||
# end
|
||||
# }
|
||||
#end
|
||||
def update_rotten_items
|
||||
all_items.each do |item|
|
||||
next unless item.raw_date
|
||||
|
||||
tmpDropAMT = item.raw_date.to_i.nonzero? || 1
|
||||
next if tmpDropAMT <= 0
|
||||
|
||||
if $game_date.dateAmt % tmpDropAMT == 0
|
||||
current_amt = item_number(item).to_i
|
||||
next if current_amt <= 0
|
||||
|
||||
amt = 1 + rand(current_amt)
|
||||
|
||||
if item.rot_progress
|
||||
raw_progress_item = item.rot_progress[0]
|
||||
raw_progress_amt = item.rot_progress[1]
|
||||
gain_item(raw_progress_item, raw_progress_amt * amt)
|
||||
end
|
||||
|
||||
lose_item(item, amt, true)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def drop_all_items_to_storage(include_equip=false,storageID=65535,except=["Key","Bondage","Hair","Trait", "Child"],skipfrist=false)
|
||||
drop_items_to_storage(storageID,except,skipfrist)
|
||||
drop_all_equipped_items_to_storage(storageID,except,skipfrist) if include_equip
|
||||
end
|
||||
|
||||
|
||||
#drop_tgt_item_and_summon(item_name,amt)
|
||||
#$data_items.select{|item| item.item_name.eql?()}[itemid]
|
||||
def drop_tgt_item_and_summon(type,item_name,amt,summon=true)
|
||||
case type
|
||||
when "Item";item=$data_items.select{|item| !item.nil? && item.item_name.eql?(item_name)};
|
||||
when "Weapon";item=$data_weapons.select{|item| !item.nil? &&item.item_name.eql?(item_name)};
|
||||
when "Armor";item=$data_armors.select{|item| !item.nil? &&item.item_name.eql?(item_name)};
|
||||
else raise "unknown type=>#{type} while drop_tgt_item_and_summon";
|
||||
end
|
||||
raise "no item of name=#{item_name} found in Database" if item.nil?
|
||||
poseession=item_number(item[0])
|
||||
amt=poseession if amt >poseession
|
||||
p "poseession =>#{poseession}"
|
||||
lose_item(item[0],amt)
|
||||
p "amt,item[0].item_name #{amt},#{item[0].item_name}"
|
||||
$game_temp.call_item_drop(Array.new(amt,item[0].item_name)) if summon
|
||||
end
|
||||
|
||||
|
||||
|
||||
end
|
||||
Reference in new issue
Block a user