Files
2026-10-29 21:59:06 +04:00

1786 lines
60 KiB
Ruby

#==============================================================================
# This script has been altered by Kslander for the need of LonaRPG
#==============================================================================
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles actors. It is used within the Game_Actors class
# ($game_actors) and is also referenced from the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
include Moods
include Cums
include Reproduction
include Battle_System
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :name # Name
attr_accessor :nickname # Nickname
attr_reader :character_name # character graphic filename
attr_reader :character_index # character graphic index
attr_reader :face_name # face graphic filename
attr_reader :face_index # face graphic index
attr_accessor :class_id # class ID
attr_accessor :level # level
attr_accessor :action_input_index # action number being input
attr_accessor :last_skill # For cursor memorization: Skill
attr_accessor :statMap #????(???PORTRAIT???)????canvas????LonaPortrait??
attr_accessor :equips
attr_accessor :immune_damage
attr_accessor :immune_state_effect
attr_accessor :immune_tgt_states #player immune those state
attr_accessor :immune_tgt_state_type #player immune those state
attr_accessor :original_immune_tgt_states #original immune state
attr_accessor :hit_LinkToMaster
attr_accessor :master
attr_accessor :shieldEV
attr_accessor :is_object
attr_accessor :is_a_ProtectShield
attr_accessor :is_tiny
attr_accessor :is_small
attr_accessor :is_flyer
attr_accessor :is_boss
attr_reader :weight_carried
attr_accessor :chs_configured
attr_accessor :stat_changed #verb req update LonaCHS and portrait
attr_accessor :skill_changed
attr_reader :actStat
attr_reader :receiver_type
attr_reader :state_steps
attr_reader :state_frames
attr_accessor :user_redirect
attr_accessor :ext_items
attr_accessor :fucker_target #???????????????grab????????????
attr_accessor :prev_health
attr_accessor :prev_sta
attr_accessor :equip_part_covered
attr_accessor :pubicHair_Vag_GrowCount
attr_accessor :pubicHair_Vag_GrowRate
attr_accessor :pubicHair_Vag_GrowMAX
attr_accessor :pubicHair_Anal_GrowCount
attr_accessor :pubicHair_Anal_GrowRate
attr_accessor :pubicHair_Anal_GrowMAX
attr_accessor :part_key_blacklist
#from STAT_SETTINGS, STAT_SETTING???Editables/94...rb ? Editables/96...rb??
STATMAP_INITIALIZED="-"
STAT_CHANGED=7
BUFF_TMIN=6
BUFF_TMAX=5
MIN_TRUE=4
MAX_TRUE=3
MAX_STAT=2
MIN_STAT=1
CURRENT_STAT=0
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(actor_id)
super()
setup(actor_id)
@last_skill = Game_BaseItem.new
@action_state=:none
@skill_changed=true
@user_redirect=false
@receiver_type = 5
@fucker_target=nil
end
#--------------------------------------------------------------------------
# * Setup
#--------------------------------------------------------------------------
def init_statMap
@statMap={"char_name" =>"Lona",
"canvas"=>System_Settings::LONA_PORTRAIT_CANVAS_SETTING,
"pose"=>"pose1"
}
self.stat["pose"]=@statMap["pose"]
end
#def lona_gears
# ["equip_head","equip_TopExtra","equip_hair","equip_Top","equip_MidExtra","equip_Mid","equip_Bot","SecondArm","MainArm"]
#end
def setup(actor_id)
p "actor setup actor_id=>#{actor_id}"
@actor_id = actor_id
@name = actor.name
@nickname = actor.nickname
init_graphics
@class_id = actor.class_id
@level = actor.initial_level
@exp = {}
@ext_items = [nil,nil,nil,nil,nil]
@equips = []
@hom_effects_data = []
@immune_tgt_states = []
@original_immune_tgt_states = []
@immune_tgt_state_type = []
@equip_part_covered = []
@part_key_blacklist = []
#@add_specs=Note.get_data(actor.note)
#@chs_configured=@add_specs["chs_config"] #old data we dont need it anymore?
@debug_attribute=false
@mouth_block=0
@weigth_carried=0 #?????????
@max_stats=Hash.new
@hit_LinkToMaster = false
@is_object = false
@immune_state_effect = false
@immune_damage = false
@master = nil
@actStat=LonaActorStat.new #??????????????stat??????????????????????????????
@actStat.npc_name="Lona"
@state_frames={}
@name_order = $data_lona_portrait[0]
init_exp
init_lonaStat #??????@stat???????portrait?????@prt_stat??
init_statMap
initialize_battle_system
stat["Race"] = "Human"
stat["always"]="on"
stat["persona"]="typical"
stat["sex_pos"]=-1
init_cums
clear_param_plus
clear_states
init_rec_stats #96_Game_Actor_Attribute.rb
@prev_health = self.health
@prev_sta = self.sta
@actStat.check_stat_old
@actStat.actor = self
end
# called in DataManager.setup_new_game
def post_setup
init_equips(actor.equips)
init_skills
init_code_in_editable #???Editable
setup_first_cycle
update_lonaStat_tera
end
def init_lonaStat
#portrait?configuration
@prt_stat=Hash.new
#state
for x in 0..$data_states.length
next if $data_states[x].nil?
next if $data_states[x].note.eql? "" && !$data_states[x].lonaStat_json_hash
next unless note=$data_states[x].note || $data_states[x].lonaStat_json_hash
$data_states[x].lonaStat_json_hash ? statHash=$data_states[x].lonaStat_json_hash : statHash=Note.get_data(note)
$data_states[x].createLonaState(statHash) if !$data_states[x].lonaStat
statName=statHash["stat"]
next if !statName
if(statHash["type"].eql?("numeric"))
statInitial=statHash["initial"].to_i
else
statInitial=statHash["initial"]
end
@prt_stat[statName]=statInitial
end
#???????????????
for u in 0..$data_weapons.length
next if $data_weapons[u].nil?
next if $data_weapons[u].note.eql?("") && !$data_weapons[u].lonaStat_json_hash
$data_weapons[u].lonaStat_json_hash ? statHash=$data_weapons[u].lonaStat_json_hash : statHash=Note.get_data($data_weapons[u].note)
$data_weapons[u].createLonaState(statHash) if !$data_weapons[u].lonaStat
$data_weapons[u].lonaStat_json_hash = nil
@prt_stat[statHash["stat"]]=""
end
#???????????????
for e in 0..$data_armors.length
next if $data_armors[e].nil?
next if $data_armors[e].note.eql?("") && !$data_armors[e].lonaStat_json_hash
$data_armors[e].lonaStat_json_hash ? statHash=$data_armors[e].lonaStat_json_hash : statHash=Note.get_data($data_armors[e].note)
$data_armors[e].createLonaState(statHash) if !$data_armors[e].lonaStat
$data_armors[e].lonaStat_json_hash = nil
@prt_stat[statHash["stat"]]=""
end
@prt_stat["head"]="head"
@prt_stat["subpose"]=1
@prt_stat["dirt"]=0
@prt_stat["preg"]=0
@prt_stat["always"]="on"
@prt_stat["persona"]="typical"
@prt_stat["sex_pos"]=-1
end
#--------------------------------------------------------------------------
# * Get Actor Object
#--------------------------------------------------------------------------
def actor
$data_actors[@actor_id]
end
#--------------------------------------------------------------------------
# * Initialize Graphics
#--------------------------------------------------------------------------
def init_graphics
@character_name = actor.character_name
@character_index = actor.character_index
#@face_name = actor.face_name
#@face_index = actor.face_index
end
def charName
@name
end
def portrait
$game_portraits.getPortrait(@name)
end
#??STA
#STA????TerrainTag???????Game_Player??????Game_Map??
def deduct_sta(value)
@sta-=value
#output p "sta : "+@sta.to_s+"src = Game_Actor"
check_sta_event
end
#??sta???????????????
def check_sta_event
check_day_night
check_tired
end
#????????
def check_day_night
#if(@sta<@napThreshold)
# $game_map.day_night_switch
# end
end
#???????????????????
def check_tired
end
def setup_state(state_id,target_stack) #?????STATE???
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "max_state_stack? #{state_id} not found",1 if !state_id
cur_state_count= state_stack(state_id)
actionCount=target_stack-cur_state_count
return if actionCount>=0 and max_state_stack?(state_id)
actCount=actionCount.abs
return if actCount==0
for c in 0...actCount
if(actionCount>0)
add_state(state_id)
else
remove_state_stack(state_id)
end
end
end
#--------------------------------------------------------------------------
# * Get Total EXP Required for Rising to Specified Level
#--------------------------------------------------------------------------
def exp_for_level(level)
self.class.exp_for_level(level)
end
#--------------------------------------------------------------------------
# * Initialize EXP
#--------------------------------------------------------------------------
def init_exp
@exp[@class_id] = current_level_exp
end
#--------------------------------------------------------------------------
# * Get Experience
#--------------------------------------------------------------------------
def exp
@exp[@class_id]
end
#--------------------------------------------------------------------------
# * Get Minimum EXP for Current Level
#--------------------------------------------------------------------------
def current_level_exp
exp_for_level(@level)
end
#--------------------------------------------------------------------------
# * Get EXP for Next Level
#--------------------------------------------------------------------------
def next_level_exp
exp_for_level(@level + 1)
end
#--------------------------------------------------------------------------
def max_exp
exp_for_level(self.max_level + 2)
end
#--------------------------------------------------------------------------
# * Maximum Level
#--------------------------------------------------------------------------
def max_level
actor.max_level
end
#--------------------------------------------------------------------------
# * Determine Maximum Level
#--------------------------------------------------------------------------
def max_level?
@level >= max_level
end
#--------------------------------------------------------------------------
# * Initialize Skills
#--------------------------------------------------------------------------
def init_skills
@skills = []
self.class.learnings.each do |learning|
learn_skill(learning.skill_id) if learning.level <= @level
end
end
#--------------------------------------------------------------------------
# * Initialize Equipment
# equips: An array of initial equipment
#--------------------------------------------------------------------------
#def init_equips(equips)
# @equips = Array.new(equip_slots.size) { Game_BaseItem.new }
# equips.each_with_index do |item_id, i|
# etype_id = index_to_etype_id(i)
# slot_id = empty_slot(etype_id)
# @equips[slot_id].set_equip(etype_id == 0, item_id) if slot_id
# end
# refresh
# equip_extra_starting_equips
#end
#init_equip calls refresh before everything is setup for update_lonaStat.
def init_equips(equips)
@equips = Array.new(equip_slots.size) { Game_BaseItem.new }
equips.each_with_index do |item_id, i|
#etype_id = index_to_etype_id(i)
etype_id = i
slot_id = empty_slot(etype_id)
report_portrait_stat(@equips[slot_id].object.lonaStat.statName, nil) if !@equips[slot_id].object.nil?
is_weapon = $data_system.weapon_slots.include?(etype_id)
@equips[slot_id].set_equip(is_weapon, item_id) if slot_id #########<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<, is weapon?
report_portrait_stat(@equips[slot_id].object.lonaStat.statName, @equips[slot_id].object.lonaStat.affectValue) if !@equips[slot_id].object.nil?
end
#refresh # not everything is set up for update_lonaStat at this point. So refresh will come later.
#from 119_ACE_Equip.rb equip_extra_starting_equips
for equip_name in $data_system.starting_equip["NoerNormal"]
tgt_gear = $data_ItemName[equip_name]
next if tgt_gear.nil?
etype_id = tgt_gear.etype_id
next unless equip_slots.include?(etype_id)
slot_id = empty_slot(etype_id)
report_portrait_stat(@equips[slot_id].object.lonaStat.statName, nil) if !@equips[slot_id].object.nil?
is_weapon = $data_system.weapon_slots.include?(etype_id)
@equips[slot_id].set_equip(is_weapon, tgt_gear.id) #########<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<, is weapon?
report_portrait_stat(@equips[slot_id].object.lonaStat.statName, @equips[slot_id].object.lonaStat.affectValue) if !@equips[slot_id].object.nil?
end
#refresh # It also calls refresh. And later yet again.
refresh_equip_effects #update_lonaStat will be called soon and it needs carryWeight
end
#--------------------------------------------------------------------------
# * Convert Index Set by Editor to Equipment Type ID
#--------------------------------------------------------------------------
# def index_to_etype_id(index)
# index
# end
#--------------------------------------------------------------------------
# * Convert from Equipment Type to List of Slot IDs
#--------------------------------------------------------------------------
def slot_list(etype_id)
result = []
equip_slots.each_with_index {|e, i| result.push(i) if e == etype_id }
result
end
#--------------------------------------------------------------------------
# * Convert from Equipment Type to Slot ID (Empty Take Precedence)
#--------------------------------------------------------------------------
def empty_slot(etype_id)
list = slot_list(etype_id)
list.find {|i| @equips[i].is_nil? } || list[0]
end
#--------------------------------------------------------------------------
# overwrite method: equip_slots
#--------------------------------------------------------------------------
def equip_slots
#return equip_slots_dual if dual_wield?
return equip_slots_normal
end
#--------------------------------------------------------------------------
# new method: equip_slots_normal
#--------------------------------------------------------------------------
def equip_slots_normal
return self.actor.base_equip_slots if self.actor.base_equip_slots != []
return self.class.base_equip_slots
end
#--------------------------------------------------------------------------
# * Get Weapon Object Array
#--------------------------------------------------------------------------
def weapons
@equips.select {|item| item.is_weapon? }.collect {|item| item.object }
end
#--------------------------------------------------------------------------
# * Get Armor Object Array
#--------------------------------------------------------------------------
def armors
@equips.select {|item| item.is_armor? }.collect {|item| item.object }
end
#--------------------------------------------------------------------------
# * Get Equipped Item Object Array
#--------------------------------------------------------------------------
def equips
@equips.collect {|item| item.object }
end
#--------------------------------------------------------------------------
# * Determine if Equipment Change Possible
# slot_id: Equipment slot ID
#--------------------------------------------------------------------------
def equip_change_ok?(slot_id)
slot_id = $data_system.equip_type_name[slot_id] if slot_id.is_a?(String)
return false if equip_slot_fixed?(equip_slots[slot_id])
return false if equip_slot_sealed?(equip_slots[slot_id])
return true
end
#--------------------------------------------------------------------------
# * Change Equipment
# slot_id: Equipment slot ID
# item: Weapon/armor (remove equipment if nil)
#--------------------------------------------------------------------------
def change_equip(slot_id, item)
slot_id = $data_system.equip_type_name[slot_id] if slot_id.is_a?(String)
item = $data_ItemName[item] if item.is_a?(String)
oldItem = @equips[slot_id].object #if @equips[slot_id] ########## tera part
########## ace part
if item.nil? && !@optimize_clear
etype_id = equip_slots[slot_id]
return unless $data_system.equip_type[etype_id][1]
elsif item.nil? && @optimize_clear
etype_id = equip_slots[slot_id]
return unless $data_system.equip_type[etype_id][2]
end
@equips[slot_id] = Game_BaseItem.new if @equips[slot_id].nil?
########## ace part
########## rgss part
return unless trade_item_with_party(item, equips[slot_id]) #dont delete this... or item will dispare.
return if item && equip_slots[slot_id] != item.etype_id
@equips[slot_id].object = item
refresh_equip_part_covered
map_token.light_check
refresh
update_chs
$game_player.refresh_chs
########## tera part
newItem = @equips[slot_id].object
if newItem!=oldItem then
report_portrait_stat(oldItem.lonaStat.statName, nil) if !oldItem.nil?
report_portrait_stat(newItem.lonaStat.statName, newItem.lonaStat.affectValue) if !newItem.nil?
end
end
def refresh_equip_part_covered
@equip_part_covered = []
for i in 0...equips.length
eqp=equips[i]
next if eqp.nil?
@equip_part_covered = (@equip_part_covered+eqp.equip_part_covered).uniq if eqp.equip_part_covered
end
end
#--------------------------------------------------------------------------
# * Forcibly Change Equipment
# slot_id: Equipment slot ID
# item: Weapon/armor (remove equipment if nil)
#--------------------------------------------------------------------------
def force_change_equip(slot_id, item)
@equips[slot_id].object = item
release_unequippable_items(false)
refresh
end
#--------------------------------------------------------------------------
# * Trade Item with Party
# new_item: Item to get from party
# old_item: Item to give to party
#--------------------------------------------------------------------------
def trade_item_with_party(new_item, old_item)
return false if new_item && !$game_party.has_item?(new_item)
$game_party.gain_item(old_item, 1)
$game_party.lose_item(new_item, 1)
return true
end
#--------------------------------------------------------------------------
# * Change Equipment (Specify with ID)
# slot_id: Equipment slot ID
# item_id: Weapons/armor ID
#--------------------------------------------------------------------------
def change_equip_by_id(slot_id, item_id)
if equip_slots[slot_id] == 0
change_equip(slot_id, $data_weapons[item_id])
else
change_equip(slot_id, $data_armors[item_id])
end
end
#--------------------------------------------------------------------------
# * Discard Equipment
# item: Weapon/armor to discard
#--------------------------------------------------------------------------
def discard_equip(item)
report_portrait_stat(item.lonaStat.statName, nil) if item && item.lonaStat
slot_id = equips.index(item)
@equips[slot_id].object = nil if slot_id
end
#--------------------------------------------------------------------------
# * Remove Equipment that Cannot Be Equipped
# item_gain: Return removed equipment to party.
#--------------------------------------------------------------------------
def release_unequippable_items(item_gain = true)
loop do
last_equips = equips.dup
@equips.each_with_index do |item, i|
if !equippable?(item.object) || item.object.etype_id != equip_slots[i]
if !item.object.nil?
report_portrait_stat(item.object.lonaStat.statName, nil)
end
trade_item_with_party(nil, item.object) if item_gain
item.object = nil
end
end
return if equips == last_equips
end
end
#--------------------------------------------------------------------------
# * Remove All Equipment
#--------------------------------------------------------------------------
def clear_equipments
equip_slots.size.times do |i|
change_equip(i, nil) if equip_change_ok?(i)
end
end
#--------------------------------------------------------------------------
# * Ultimate Equipment
#--------------------------------------------------------------------------
def optimize_equipments
clear_equipments
equip_slots.size.times do |i|
next if !equip_change_ok?(i)
items = $game_party.equip_items.select do |item|
item.etype_id == equip_slots[i] &&
equippable?(item) && item.performance >= 0
end
change_equip(i, items.max_by {|item| item.performance })
end
end
#--------------------------------------------------------------------------
# * Determine if Skill-Required Weapon Is Equipped
#--------------------------------------------------------------------------
#def skill_wtype_ok?(skill)
# wtype_id1 = skill.required_wtype_id1
# wtype_id2 = skill.required_wtype_id2
# return true if wtype_id1 == 0 && wtype_id2 == 0
# return true if wtype_id1 > 0 && wtype_equipped?(wtype_id1)
# return true if wtype_id2 > 0 && wtype_equipped?(wtype_id2)
# return false
#end
#--------------------------------------------------------------------------
# * Determine if Specific Type of Weapon Is Equipped
#--------------------------------------------------------------------------
def wtype_equipped?(wtype_id)
weapons.any? {|weapon| weapon.wtype_id == wtype_id }
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
release_unequippable_items
@actStat.reset_reality_stats #????????????pry_plus?? pry_plus???????
@actStat.reset_definition
@actStat.reset_stat_def
refresh_effects
@skill_changed =true
refresh_ext_item
#super
@actStat.check_stat_old
recalculate_stats
end
def refresh_effects
@hom_effects_data = []
refresh_equip_effects
refresh_state_effects
end
#--------------------------------------------------------------------------
# * Determine if Actor or Not
#--------------------------------------------------------------------------
def actor?
return true
end
#--------------------------------------------------------------------------
# * Get Allied Units
#--------------------------------------------------------------------------
def friends_unit
$game_party
end
#--------------------------------------------------------------------------
# * Get Enemy Units
#--------------------------------------------------------------------------
def opponents_unit
$game_troop
end
#--------------------------------------------------------------------------
# * Get Actor ID
#--------------------------------------------------------------------------
def id
@actor_id
end
#--------------------------------------------------------------------------
# * Get Index
#--------------------------------------------------------------------------
def index
$game_party.members.index(self)
end
#--------------------------------------------------------------------------
# * Determine Battle Members
#--------------------------------------------------------------------------
def battle_member?
$game_party.battle_members.include?(self)
end
#--------------------------------------------------------------------------
# * Get Class Object
#--------------------------------------------------------------------------
def class
$data_classes[@class_id]
end
#--------------------------------------------------------------------------
# * Get Skill Object Array
#--------------------------------------------------------------------------
def skills
(@skills | added_skills).sort.collect {|id| $data_skills[id] }
end
#--------------------------------------------------------------------------
# * Get Array of Currently Usable Skills
#--------------------------------------------------------------------------
def usable_skills
skills.select {|skill| usable?(skill) }
end
def movable?
true
end
#--------------------------------------------------------------------------
# * Get Array of All Objects Retaining Features
#--------------------------------------------------------------------------
def feature_objects
#super + [actor] + equips.compact
super + [actor] + [self.class] + equips.compact
end
#--------------------------------------------------------------------------
# * Get Attack Element
#--------------------------------------------------------------------------
def atk_elements
set = super
set |= [1] if weapons.compact.empty? # Unarmed: Physical element
return set
end
#--------------------------------------------------------------------------
# * Get Maximum Value of Parameter
#--------------------------------------------------------------------------
def param_max(param_id)
return 9999 if param_id == 0 # MHP
return super
end
#--------------------------------------------------------------------------
# * Get Base Value of Parameter
#--------------------------------------------------------------------------
def param_base(param_id)
self.class.params[param_id, @level]
end
#--------------------------------------------------------------------------
# * Get Added Value of Parameter
#--------------------------------------------------------------------------
def param_plus(param_id)
equips.compact.inject(super) {|r, item| r += item.params[param_id] }
end
#--------------------------------------------------------------------------
# * Get Normal Attack Animation ID
#--------------------------------------------------------------------------
def atk_animation_id1
#if dual_wield?
# return weapons[0].animation_id if weapons[0]
# return weapons[1] ? 0 : 1
# else
return weapons[0] ? weapons[0].animation_id : 1
# end
end
#--------------------------------------------------------------------------
# * Get Animation ID of Normal Attack (Dual Wield: Weapon 2)
#--------------------------------------------------------------------------
def atk_animation_id2
# if dual_wield?
# return weapons[1] ? weapons[1].animation_id : 0
# else
return 0
# end
end
#--------------------------------------------------------------------------
# * Change Experience
# show : Level up display flag
#--------------------------------------------------------------------------
def change_exp(exp, show)
return if self.exp >= self.max_exp
@exp[@class_id] = [exp, 0].max
last_level = @level
last_skills = skills
level_up while !max_level? && self.exp >= next_level_exp
level_down while self.exp < current_level_exp
display_level_up(skills - last_skills) if show && @level > last_level
#refresh #will cause laggy
end
#--------------------------------------------------------------------------
# * Get Experience
#--------------------------------------------------------------------------
def exp
@exp[@class_id]
end
#--------------------------------------------------------------------------
# * Level Up
#--------------------------------------------------------------------------
def level_up
@level += 1
@trait_point +=1
self.class.learnings.each do |learning|
learn_skill(learning.skill_id) if learning.level == @level
end
end
#--------------------------------------------------------------------------
# * Level Down
#--------------------------------------------------------------------------
def level_down
@level -= 1
end
#--------------------------------------------------------------------------
# * Show Level Up Message
# new_skills : Array of newly learned skills
#--------------------------------------------------------------------------
def display_level_up(new_skills)
SndLib.sys_LvUp
$game_map.popup(0,"Level UP",0,0)
end
#--------------------------------------------------------------------------
# * Get EXP (Account for Experience Rate)
#--------------------------------------------------------------------------
def gain_exp(exp)
change_exp(self.exp + (exp * final_exp_rate).to_i, true)
end
#--------------------------------------------------------------------------
# * Calculate Final EXP Rate
#--------------------------------------------------------------------------
def final_exp_rate
1.0 * (battle_member? ? 1 : reserve_members_exp_rate)
end
#--------------------------------------------------------------------------
# * Get EXP Rate for Reserve Members
#--------------------------------------------------------------------------
def reserve_members_exp_rate
$data_system.opt_extra_exp ? 1 : 0
end
#--------------------------------------------------------------------------
# * Change Level
# show : Level up display flag
#--------------------------------------------------------------------------
def change_level(level, show)
level = [[level, max_level].min, 1].max
change_exp(exp_for_level(level), show)
end
#--------------------------------------------------------------------------
# * Learn Skill
#--------------------------------------------------------------------------
def learn_skill(skill_id)
skill_id = $data_SkillName[skill_id].id if skill_id.is_a?(String)
unless skill_learn?($data_skills[skill_id])
@skills.push(skill_id)
@skills.sort!
end
end
#--------------------------------------------------------------------------
# * Forget Skill
#--------------------------------------------------------------------------
def forget_skill(skill_id)
@skills.delete(skill_id)
@skills.sort!
end
#--------------------------------------------------------------------------
# * Determine if Skill Is Already Learned
#--------------------------------------------------------------------------
def skill_learn?(skill)
skill.is_a?(RPG::Skill) && @skills.include?(skill.id)
end
def skill_id_usable?(tmp_skill_id)
tmpSkillList = (@skills | added_skills).sort
tmpSkillList.include?(tmp_skill_id)
end
#--------------------------------------------------------------------------
# * Get Description
#--------------------------------------------------------------------------
def description
actor.description
end
#--------------------------------------------------------------------------
# * Change Class
# keep_exp: Keep EXP
#--------------------------------------------------------------------------
#def change_class(class_id, keep_exp = false)
# @exp[class_id] = exp if keep_exp
# @class_id = class_id
# change_exp(@exp[@class_id] || 0, false)
# refresh
#end
#--------------------------------------------------------------------------
# * Change Graphics
#--------------------------------------------------------------------------
def set_graphic(character_name, character_index, face_name, face_index)
@character_name = character_name
@character_index = character_index
#@face_name = face_name
#@face_index = face_index
end
#--------------------------------------------------------------------------
# * Use Sprites?
#--------------------------------------------------------------------------
def use_sprite?
return false
end
#--------------------------------------------------------------------------
# * Execute Damage Effect
#--------------------------------------------------------------------------
def perform_damage_effect
$game_troop.screen.start_shake(5, 5, 5)
@sprite_effect_type = :blink
Sound.play_actor_damage
end
#--------------------------------------------------------------------------
# * Execute Collapse Effect
#--------------------------------------------------------------------------
def perform_collapse_effect
if $game_party.in_battle
@sprite_effect_type = :collapse
Sound.play_actor_collapse
end
end
#--------------------------------------------------------------------------
# * Create Action Candidate List for Auto Battle
#--------------------------------------------------------------------------
def make_action_list
return
list = []
list.push(Game_Action.new(self).set_attack.evaluate)
usable_skills.each do |skill|
list.push(Game_Action.new(self).set_skill(skill.id).evaluate)
end
list
end
#--------------------------------------------------------------------------
# * Create Action During Auto Battle
#--------------------------------------------------------------------------
def make_auto_battle_actions
@actions.size.times do |i|
@actions[i] = make_action_list.max_by {|action| action.value }
end
end
#--------------------------------------------------------------------------
# * Create Action During Confusion
#--------------------------------------------------------------------------
def make_confusion_actions
@actions.size.times do |i|
@actions[i].set_confusion
end
end
#--------------------------------------------------------------------------
# * Create Battle Action
#--------------------------------------------------------------------------
def make_actions
super
if auto_battle?
make_auto_battle_actions
elsif confusion?
make_confusion_actions
end
end
#--------------------------------------------------------------------------
# * Processing Performed When Player Takes 1 Step
#--------------------------------------------------------------------------
def on_player_walk
@result.clear
if map_token.normal_walk?
#turn_end_on_map
states.uniq.each {|state| update_state_steps(state) }
end
end
#--------------------------------------------------------------------------
# * Update Step Count for State
#--------------------------------------------------------------------------
def update_state_steps(state)
if state.remove_by_walking && state_stack(state.id)> 0
@state_steps[state.id] -= 1 if @state_steps[state.id] > 0
#p "#{state.item_name} #{@state_steps[state.id]} #{state.steps_to_remove} #{state_stack(state.id)} asdasdasd"
if @state_steps[state.id] <= 0
#@state_steps[state.id] = state.steps_to_remove #if state_stack(state.id) >=1
@state_steps[state.id] = state.steps_to_remove
@state_frames[state.id] = state.steps_to_remove * 60
remove_state_stack(state.id)
end
end
end
#--------------------------------------------------------------------------
# * Show Added State
#--------------------------------------------------------------------------
def show_added_states
@result.added_state_objects.each do |state|
$game_message.add(name + state.message1) unless state.message1.empty?
end
end
def update_state_frames
states.uniq.each{|state|
#p "stack=>#{state_stack(state.id)} ,@state_steps[#{state.id}]=>#{@state_steps[state.id]} @state_frames[#{state.id}]=>#{@state_frames[state.id]}" if state.id == 161
if state.remove_by_walking && state_stack(state.id)> 0
@state_frames[state.id] -= 1 if @state_frames[state.id] > 0
#p "#{state.item_name} #{@state_steps[state.id]} #{state.steps_to_remove} #{state_stack(state.id)} asdasdasd"
if @state_frames[state.id] <= 0
@state_steps[state.id] = state.steps_to_remove
@state_frames[state.id] = state.steps_to_remove * 60
remove_state_stack(state.id)
next # or it will remove all stack
end
end
}
end
#--------------------------------------------------------------------------
# * ?? lona_stat
#--------------------------------------------------------------------------
def update_lonaStat
#It was called in update_lonaStat so I guess it might be important for some states.
#But update_lonaStat is called from so many places that it's strange.
#for example, when loading. In other words, one can save/load until status that can be removed by walking is gone...
update_state_frames
end
def update_lonaStat_old
updatedLonaGears=Array.new
@actStat.check_stat #why double update? i dont know?
stat["mood"]=self.mood
stat["dirt"]=self.dirt
stat["sta"]=self.sta
update_state_link
for eqn in 0...@equips.length
next if @equips[eqn].object.nil?
statName=@equips[eqn].object.lonaStat.statName
stat[statName]=@equips[eqn].object.lonaStat.affectValue
updatedLonaGears.push(statName)
end
updatedLonaGears = $data_system.gear_stats_update_flow - updatedLonaGears
#updatedLonaGears=lona_gears-updatedLonaGears
for x in 0...updatedLonaGears.length
gearName=updatedLonaGears[x]
stat[gearName]=nil
end
recalculate_stats
update_state_frames
update_on_update_lonaStat #editable 97.rb #moved to mod folder
@actStat.check_stat #why not just # it?
end
def recalculate_stats
self.constitution= self.constitution_trait+self.constitution_plus
self.survival= self.survival_trait+self.survival_plus
self.wisdom= self.wisdom_trait+self.wisdom_plus
self.combat= self.combat_trait+self.combat_plus
self.scoutcraft= self.scoutcraft_trait+self.scoutcraft_plus
self.atk= (self.combat*0.5) + self.atk_plus
self.def= self.def_plus
update_sex_atk
self.morality= self.morality_lona + (self.morality_plus-200)
self.hud_weight_count= 2*self.attr_dimensions["sta"][2] - self.weight_carried
end
def update_lonaStat_tera
update_lonaStat_old
@actStat.check_stat_old
end
def update_state_link
# cursed
tgtStates = self.states.uniq
return if tgtStates.empty?
tgtStates.each{|cState|
next if cState.nil? || cState.lonaStat.nil?
state_id=cState.id
next if cState.lonaStat.isStringType?
if cState.lonaStat.statLink # if link pick MAX. probably with bugs?
#stat[cState.lonaStat.statName] = 0 if !stat[cState.lonaStat.statName] #2024 2 28 > make some support to old save
stat[cState.lonaStat.statName]=[stat[cState.lonaStat.statName],state_stack(state_id)].max
else
stat[cState.lonaStat.statName]=state_stack(state_id)
end
}
end
def refresh_part_key_blacklist
@part_key_blacklist = []
@banned_receiver_holes = []
feature_objects.uniq.each {|o|
@banned_receiver_holes += o.banned_receiver_holes if o.banned_receiver_holes # should belong to refresh_banned_supported_receiver_slot. but i m lazy.
@part_key_blacklist += o.part_key_blacklist if o.part_key_blacklist && !o.part_key_blacklist.empty?
}
@part_key_blacklist = @part_key_blacklist.uniq
$chs_data["Lona"].part_key_blacklist = @part_key_blacklist
self.portrait.part_key_blacklist = @part_key_blacklist #moved to 09_Lona_Portrait init and refresh
end
def calculate_weight_carried
@weight_carried=0
#?????
$game_party.all_items.each{|itm|
@weight_carried+=($game_party.item_number(itm)*itm.weight)
}
equips.each{|eqp|
next if eqp.nil?
@weight_carried+=eqp.weight
}
@weight_carried=@weight_carried.round(3)
#p "weight updated weight:#{@weight_carried}" if @debug_attribute
end
#--------------------------------------------------------------------------
# * Show Removed State
#--------------------------------------------------------------------------
def show_removed_states
@result.removed_state_objects.each do |state|
$game_message.add(name + state.message4) unless state.message4.empty?
end
end
#--------------------------------------------------------------------------
# * Number of Steps Regarded as One Turn in Battle
#--------------------------------------------------------------------------
def steps_for_turn
return 20
end
#--------------------------------------------------------------------------
# * End of Turn Processing on Map Screen
#--------------------------------------------------------------------------
#def turn_end_on_map
# if $game_party.steps % steps_for_turn == 0
# on_turn_end
# perform_map_damage_effect if @result.hp_damage > 0
# end
#end
#--------------------------------------------------------------------------
# * Determine Floor Effect
#--------------------------------------------------------------------------
# def check_floor_effect
# execute_floor_damage if map_token.on_damage_floor?
# end
#--------------------------------------------------------------------------
# * Floor Damage Processing
#--------------------------------------------------------------------------
#def execute_floor_damage
# damage = (basic_floor_damage * fdr).to_i
# self.hp -= [damage, max_floor_damage].min
# perform_map_damage_effect if damage > 0
#end
#--------------------------------------------------------------------------
# * Get Base Value for Floor Damage
#--------------------------------------------------------------------------
def basic_floor_damage
return 10
end
#--------------------------------------------------------------------------
# * Get Maximum Value for Floor Damage
#--------------------------------------------------------------------------
def max_floor_damage
$data_system.opt_floor_death ? hp : [hp - 1, 0].max
end
#--------------------------------------------------------------------------
# * Execute Damage Effect on Map
#--------------------------------------------------------------------------
def perform_map_damage_effect
$game_map.screen.start_flash_for_damage
end
#--------------------------------------------------------------------------
# * Clear Actions
#--------------------------------------------------------------------------
def clear_actions
super
@action_input_index = 0
end
#--------------------------------------------------------------------------
# * Get Action Being Input
#--------------------------------------------------------------------------
def input
@actions[@action_input_index]
end
#--------------------------------------------------------------------------
# * To Next Command Input
#--------------------------------------------------------------------------
def next_command
return false if @action_input_index >= @actions.size - 1
@action_input_index += 1
return true
end
#--------------------------------------------------------------------------
# * To Previous Command Input
#--------------------------------------------------------------------------
def prior_command
return false if @action_input_index <= 0
@action_input_index -= 1
return true
end
#??????????
def show_states
p @states
end
# #??Lona_Gear???????????????????
# def lona_gears
# ["equip_TopExtra","MainArm","WhateverEquipMayAffectStatmap"]
# end
#?????????????????(>=2*MSTA)
def weight_immobilized?
@weight_carried.round(1) > (@actStat.get_stat("sta",ActorStat::MAX_STAT)*2).round(1)
end
#====================================================================================================
# ?? Game_Battler.item_conditions_met????????????????
#====================================================================================================
def item_conditions_met?(item)
super #&& item.consumable
end
#?? Game_Battler.use_item???????item?????
def use_item(item)
super
if !item.player_item_usage_event_summon.nil? #???Ssummon EVENT ??????????SCENE???
$game_temp.call_item_drop([item.player_item_usage_event_summon])
end
if !item.player_item_usage_eval.nil?
eval(item.player_item_usage_eval)
end
if item.use_item_effect
item.use_item_effect.each{|le|
next if le.nil?
next unless effect_allowed?(le)
attrVal=@actStat.get_stat(le.attr,le.attr_type)
@actStat.set_stat(le.attr,self.get_affected_attr(le),le.attr_type)
}
end
self.json_addon_manage_state(item,item.player_item_usage_manage_state) if item.player_item_usage_manage_state
self.json_addon_remove_equip(item.player_item_remove_equip) if item.player_item_remove_equip
end
def refresh_state_effects
@states.each{|stateID|
next if stateID.nil?
next if $data_states[stateID].lona_effect.nil?
$data_states[stateID].lona_effect.each{|le|
next @hom_effects_data << le if le.attr_type == "current"
next unless effect_allowed?(le)
attrVal=@actStat.get_stat(le.attr,le.attr_type)
@actStat.set_stat(le.attr,self.get_affected_attr(le),le.attr_type)
}
}
end
def refresh_equip_effects
#@equip_part_covered = [] # to def change_equip
for i in 0...equips.length
eqp=equips[i]
next if eqp.nil? || eqp.is_a?(RPG::Item)
#@equip_part_covered = (@equip_part_covered+eqp.equip_part_covered).uniq if eqp.equip_part_covered
for c in 0...eqp.lona_effect.length
le=eqp.lona_effect[c]
next @hom_effects_data << le if le.attr_type == "current"
next unless effect_allowed?(le)
attrVal=@actStat.get_stat(le.attr,le.attr_type)
@actStat.set_stat(le.attr,self.get_affected_attr(le),le.attr_type)
end
end
calculate_weight_carried
end
def refresh_hom_effects
@hom_effects_data.each{|le|
next unless effect_allowed?(le)
attrVal=@actStat.get_stat(le.attr,le.attr_type)
@actStat.set_stat(le.attr,self.get_affected_attr(le),le.attr_type)
}
end
def effect_allowed?(le) # 23_Game_BattlerBase.rb
#p le.block_by_part_cover if le.block_by_part_cover
#p (le.block_by_part_cover.any? { |part| @equip_part_covered.include?(part)}) if le.block_by_part_cover
#return false if le.block_by_part_cover && le.block_by_part_cover.flatten.any? { |part| @equip_part_covered.include?(part.to_s) } #dress covered block
return false if effect_dress_covered?(le.block_by_part_cover,@equip_part_covered)
return super(le)
end
def effect_dress_covered?(block_by_part_cover, equip_part_covered)
return false unless block_by_part_cover && !block_by_part_cover.empty?
#p block_by_part_cover
#p equip_part_covered
#p !(block_by_part_cover & equip_part_covered).empty?
!(block_by_part_cover & equip_part_covered).empty?
end
def update_chs
@stat_changed=true #verb req update LonaCHS and portrait
end
def stat
@prt_stat
end
def attr_dimensions
@actStat.stat
end
def export_affected_attr(effect)
@actStat.get_stat(effect.attr,effect.attr_type)
end
#???????= (???current:atk_plus +10)
#?????= (???current:def_plus+2)
#??= ??????? - ?????
#{damage??adjustor}
#???????1
#Damage?? {eff.damage.adjustor} ??
def take_skill_effect(user,skill,can_sap=true,force_hit=false)
return if check_is_shieldEV_and_hit_by_master?(user,skill) && !force_hit
return map_token.perform_dodge if @dodged && !skill.no_dodge
return if with_ShieldEV? && !skill.is_support
#return @shieldEV.actor.take_damage(user,skill,force_hit) if with_ShieldEV? && !skill.is_support
#check_skill_cancel_by_hit(user,skill) if @action_state != :sex
check_skill_cancel_by_hit(user,skill )if !skill.no_action_change
take_damage(user,skill,force_hit)
apply_skill_state_effect(skill,user) if !blocked?(user)
take_sap(user) if skill.sap? && can_sap && !self.immune_state_effect && !self.immune_damage
set_last_attacker(user) if !skill.is_support
update_state_frames
determine_death
end
def check_is_shieldEV_and_hit_by_master?(user,skill)
return false if !@is_a_ProtectShield
return false if !@master
return true if skill.is_support
return true if user == @master.actor
false
end
def check_skill_cancel_by_hit(user,skill)
@master.actor.player_control_mode(false) if map_token.mind_control_on_hit_cancel && @master && @master.actor
take_skill_cancel(skill) if !blocked?(user) && !actor_skill_no_interrupt?
remove_stun_by_chance
map_token.move_normal
end
def actor_skill_no_interrupt?
return false if self.skill.nil?
#p "no_interrupt_LonaOnly #{self.skill.no_interrupt_LonaOnly}"
#p "WeaponryKnowledge #{self.stat["WeaponryKnowledge"]}"
return true if self.skill.no_interrupt || (self.skill.no_interrupt_LonaOnly && self.stat["WeaponryKnowledge"] == 1)
return false
end
def determine_death
return if [:grabbed,:sex].include?(@action_state)
set_action_state(:death) if self.health <=0 || self.sta <= -100
end
def lonaDeath?
tmpResult = self.health <=0 || self.sta <= -100
self.action_state == :death || tmpResult
end
def select_skill(skillset,type)
@skill=nil
@current_animation=nil
selected=skillset.select{
|skill|
skill.range_type==type
}
selected
end
def launch_player_skill(type)
p "launch_player_skill action_state=>#{@action_state}"
skill=self.usable_skills.select{
|skill|
skill.type.eql?(type)
}[0]
return if skill.nil? || !cost_affordable?($data_arpgskills[skill.type_tag])
#p "launch_player_skill=>#{skill.type_tag}"
#p "cost_affordable?($data_arpgskills[skill.type_tag])=>#{cost_affordable?($data_arpgskills[skill.type_tag])}"
#p "launch_player_skill=>#{$data_arpgskills[skill.type_tag]}, skill.type_tag=>#{skill.type_tag}"
launch_skill($data_arpgskills[skill.type_tag])
end
#??????????target???range????
def target_in_range?(skill)
true
end
#???Battle_System??????????
def battle_stat
@actStat
end
#BattleSSyten??
def map_token
$game_player
end
def target
return @target if @target
@target = Struct::FakeTarget.new($game_map.round_x_with_direction(map_token.x, map_token.direction),$game_map.round_y_with_direction(map_token.y, map_token.direction))
end
#???fraction??????????????
def fraction
0
end
def friendly?(character)
false
#character.actor.fraction == self.fraction
end
def over_energized?
if @skill.energizing?
@holding_count >= @skill.launch_max
elsif @skill.blocking?
false
else
false
end
end
def avoid_friendly_fire?(skill)
false
end
def launch_holding_skill(skill)
super(skill)
map_token.set_animation(skill.hold_animation) if skill.hold_animation
end
def do_sap
true
end
def apply_stun_effect(state_id)
return if @action_state==:sex
#state_id = $data_StateName[state_id].id if state_id.is_a?(String)
state=$data_StateName[state_id]
return unless state.stun?
super
map_token.setup_stun_effect
end
def apply_fap_effect(state_id)
return if @action_state==:sex
#state_id = $data_StateName[state_id].id if state_id.is_a?(String)
state=$data_StateName[state_id]
return unless state.stun?
super
map_token.setup_fap_effect
end
def apply_shock_effect(state_id)
return if @action_state==:sex
#state_id = $data_StateName[state_id].id if state_id.is_a?(String)
state=$data_StateName[state_id]
return unless state.stun?
super
map_token.setup_shock_effect
end
def apply_cuming_effect(state_id)
return if @action_state==:sex
#state_id = $data_StateName[state_id].id if state_id.is_a?(String)
state=$data_StateName[state_id]
return unless state.stun?
super
map_token.setup_cuming_effect
end
def apply_pindown_effect(state_id)
return if @action_state==:sex
#state_id = $data_StateName[state_id].id if state_id.is_a?(String)
state=$data_StateName[state_id]
return unless state.stun?
super
map_token.setup_pindown_effect
end
def update_stun
return unless @action_state==:stun
return remove_stun_effect if self.stat["BerserkPack"] >= 1
@stun_count -=1
remove_stun_effect if @stun_count<=0
end
def set_action_state(action_state,force=false)
prp "player.actor.set_action_state =>#{action_state}",2
return if @action_state == :death && !force
return if action_state == @action_state && !force
map_token.cancel_stun_effect && action_state!=:stun
@action_state_changed=true
@action_state=action_state
end
#debug ?
def show_stat
prp "current , min ,max ,max_true, min_true"
@actStat.stat.keys.each{
|key|
prp "actor stat: #{key} =>#{@actStat.stat[key]}",2
}
end
def char_spotted?(character,min_signal=1)
false
end
def aggro_allowed?(attacker,skill)
false
end
def reset_skill(force=false)
super
map_token.release_chs_group if [:sex,:grabber,:grabbed].include?(@action_state)
end
def can_set_skill?(skill)
return false if skill.nil?
return false unless skill.respond_to?(:item_name)
case skill.item_name
when "sys_normal";tag="normal"
when "sys_heavy";tag="heavy"
when "sys_control";tag="control"
end
skill=get_system_skill(skill) if system_skill?(skill.item_name)
return false if skill.nil?
return false unless skill.respond_to?(:item_name) && skill.respond_to?(:stype_id) && skill.respond_to?(:type_tag)
arpg_skill = nil
begin
arpg_skill = $data_arpgskills[skill.type_tag]
rescue StandardError
arpg_skill = nil
end
return false if arpg_skill.nil?
skills.include?(skill) && !skill_sealed?(skill.item_name) && !skill_type_sealed?(skill.stype_id) && cost_affordable?(arpg_skill)
#usable_skills.include?(skill) && cost_affordable?($data_arpgskills[skill.type_tag])
end
def launch_skill(skill,force=false)
@skill_changed=true
super
end
#control,heavy,normal
def system_skill?(skill_id)
["sys_normal","sys_heavy","sys_control"].include?(skill_id)
end
def get_system_skill(skill)
case skill.item_name
when "sys_normal";tag="normal"
when "sys_heavy";tag="heavy"
when "sys_control";tag="control"
end
sys_skill=usable_skills.select{|skill|
skill.type.eql?(tag)
}[0]
sys_skill
end
def set_aggro(attacker=0,skill=9,frame_count=300,no_action_change = false)
return
end
def ranged?
false
end
def no_aggro
true
end
def set_alert_level(new_alert)
#npc function do nothing on player
end
def process_target_lost(reset_anomally)
#npc function do nothing on player
end
def age
return 1
end
def drop_list
[]
end
def npc_name
@name
end
def user_redirect
false
end
def update_skill_eff
return if $game_map.interpreter.running? || $game_message.busy?
return if set_action_state(:none) if @skill.nil?
update_energizing
if @skill_charging_state == 2 #??????????launch??????2
@skill_wait-=1
if (@skill_wait <= 0)
tmpHitAnyTGT = false
if !@current_skill_launched
process_skill_result(@skill)
map_token.move_normal unless (@skill && @skill.stealth) || self.stat["ShadowMaster"] == 1 #player unique ver because this
cancel_holding(true) if @skill && @skill.holding? && @holding_count!=-1
@current_skill_launched = true
end
return if check_skill_hit_cancel(@skill)
@last_used_skill = @skill
set_action_state(:none) if @skill && !@skill.chs_animation
map_token.skill_eff_reserved = false
@skill=nil #MG42
@skill_wait=-1
reset_skill
end
#elsif @skill.simply_holding? && @skill_charging_state == 1
# @last_used_skill = @skill
# #p @last_used_skill
end
end
def check_skill_hit_cancel(skill) #2Always 1#Last 0
return false if !skill
return false if skill.hit_cancel_mode == 0 && !skill.hit_cancel_req_a_tgt #Always
skillCompare = !skill.hit_cancel_req_a_tgt || (map_token.target && map_token.target.actor.last_hit_by_skill == skill)
return false if skill.hit_cancel_mode == 1 && skillCompare && @last_used_skill != skill #Differen
return false if skill.hit_cancel_mode == 2 && skillCompare && @last_used_skill && skill.hit_cancel_req_last_skill == @last_used_skill.name #Last
return false if skill.hit_cancel_mode == 0 && skillCompare #Always
return true if map_token.chk_skill_eff_reserved
false
end
def update_energizing # battle system player overwrite
return if @skill_charging_state==2
@holding_count += 1
if over_energized?
@skill_charging_state = 2
map_token.move_normal unless @skill.stealth || self.stat["ShadowMaster"] == 1 #player unique ver because this
cancel_holding(true)
elsif @holding_count >= @skill.launch_since
map_token.move_normal unless @skill.stealth || self.stat["ShadowMaster"] == 1 #player unique ver because this
@skill_charging_state = 1
end
end
##################### from stats mod tera
def update_state_portrait_stat(state_id)
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "update_state_portrait_stat #{state_id} not found",1 if !state_id
cState=$data_states[state_id]
if !cState.nil? && !cState.lonaStat.nil?
report_portrait_stat(cState.lonaStat.statName, state_stack(state_id)) if !cState.lonaStat.isStringType?
update_state_link if cState.lonaStat.statLink
end
end
#calls refresh before initializing state frames, instead add_state should call it in the end
def add_new_state(state_id)
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "add_new_state #{state_id} not found",1 if !state_id
die if state_id == death_state_id
@states.push(state_id)
on_restrict if restriction > 0
sort_states
update_state_portrait_stat(state_id)
#refresh
end
def erase_state(state_id)
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "erase_state #{state_id} not found",1 if !state_id
super(state_id)
update_state_portrait_stat(state_id)
end
def remove_state_stack(state_id)
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "remove_state_stack #{state_id} not found",1 if !state_id
super(state_id)
update_state_portrait_stat(state_id)
end
def add_state(state_id)
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
return prp "add_state #{state_id} not found",1 if !state_id
will_add_state=state_addable?(state_id) #condition for calling add_new_state
super(state_id)
if will_add_state then #only if add_new_state was called
refresh
eval("SndLib.#{$data_states[state_id].player_add_state_SndLib}") if $data_states[state_id].player_add_state_SndLib
update_state_portrait_stat(state_id)
end
end
def report_portrait_stat(statName, value) #separate method to allow 9999_StatPortraitOptimization.rb to hook here.
@prt_stat[statName]=value
portrait.set_stat(statName,value) if !$game_portraits.nil? && !portrait.nil?
end
def portrait_stat_value #used to intercept actor.stat[<name>] calls
return @prt_stat
end
def stat #used to intercept actor.stat[<name>] calls
if $game_actors.length > 0
return (Portrait_Stat_Proxy.new(self)).freeze
else
@prt_stat
end
end
def itemUseBatch(item)
item = $data_ItemName[item] if item.is_a?(String)
self.item_apply(self,item)
self.use_item(item)
end
end #class actor
class Game_NPC_Actor < Game_Actor
def setup(actor_id)
p "actor setup actor_id=>#{actor_id}"
@actor_id = actor_id
@name = actor_id
#init_graphics
#@class_id = actor.class_id
#@level = actor.initial_level
#@exp = {}
#@ext_items = [nil,nil,nil,nil,nil]
@equips = []
#@add_specs=Note.get_data("")
#@chs_configured=@add_specs["chs_config"]
#@stamina=0
#@debug_attribute=false
@portrait_sync=true
#@mouth_block=0
#@weigth_carried=0 #?????????
@max_stats=Hash.new
#@master = nil
#@hit_LinkToMaster = false
#@is_object = false
#@immune_state_effect = false
#@immune_damage = false
#@master = nil
@actStat=LonaActorStat.new #??????????????stat??????????????????????????????
@actStat.npc_name="NPCLayer"
@state_frames={}
@name_order = $data_lona_portrait[0]
@part_key_blacklist = []
#init_exp
init_lonaStat #??????@stat???????portrait?????@prt_stat??
init_statMap
#initialize_battle_system
#stat["Race"] = "Human"
#stat["always"]="on"
#stat["persona"]="typical"
#stat["sex_pos"]=-1
#init_cums
#clear_param_plus
#recover_all
#init_rec_stats #96_Game_Actor_Attribute.rb
#@prev_health = self.health
#@prev_sta = self.sta
#@actStat.check_stat_old
@actStat.actor = self
end
def init_lonaStat
if @actor_id != "NPCLayerMain"
@prt_stat=$game_NPCLayerMain.prt_stat
else
@prt_stat=Hash.new
end
end
def prt_stat
if @actor_id != "NPCLayerMain"
$game_NPCLayerMain.prt_stat
else
@prt_stat
end
end
def stat #used to intercept actor.stat[<name>] calls
if @actor_id != "NPCLayerMain"
return $game_NPCLayerMain.stat
else
return super
end
end
def init_statMap
if @actor_id != "NPCLayerMain"
@statMap=$game_NPCLayerMain.statMap
else
super
init_layer_stats
end
end
def init_layer_stats
self.stat["Cocona_Hsta"] = nil
self.stat["Cocona_DidWhoreJob"] = nil
self.stat["Cocona_DidWhoreJob"] = nil
self.stat["Cocona_Arousal"] = nil
self.stat["Cocona_Dress"] = "Necro"
self.stat["Cocona_GroinDamaged"] = nil
end
def nap_reset_stats
self.stat["Cocona_Hsta"] = nil
self.stat["Cocona_DidWhoreJob"] = nil
self.stat["Cocona_DidWhoreJob"] = nil
self.stat["Cocona_Arousal"] = nil
#self.stat["Cocona_Dress"] = $game_map.interpreter.cocona_maid? ? "Maid" : "Necro" #control by lona
self.stat["Cocona_GroinDamaged"] = nil if self.stat["Cocona_GroinDamaged"] && self.stat["Cocona_GroinDamaged"] <= 0
self.stat["Cocona_GroinDamaged"] -= 1 if self.stat["Cocona_GroinDamaged"]
end
def take_sap(user)
return false
end
end