#============================================================================== # ■ VXAce-RGSS3-7 閃きシステム [Ver.1.2.0] by Claimh #============================================================================== module SysFlash TYPE_NORMAL=0;TYPE_DERIVE=1;TYPE_ENEMY=2 #------------------------------------------------------------------------ # ● 併用化処理 # 連続攻撃系＋閃き無効化処理系のスクリプトと併用時の無効化処理を包含する #------------------------------------------------------------------------ def self.can_flash?(battler) #スイッチで抑制する例 # return false if $game_switches[id] return false if battler.flash_flg # 閃き動作中は不可 return false if can_multi?(battler) # 複数行動の１回でも閃いたとき return true # 閃き可能 end #------------------------------------------------------------------------ # ● 複数行動中の閃き可能？ #------------------------------------------------------------------------ def self.can_multi?(battler) return false unless NOT_MULTI_FLASH return battler.multi_flash_flg end #------------------------------------------------------------------------ # ● スキル派生可能？ #------------------------------------------------------------------------ def self.can_derive?(skill_id) return false unless DERIVE_FLASH return false if NOT_FLASH_SKILL.include?(skill_id) return true end #------------------------------------------------------------------------ # ● スキルからの通常閃き可能？ #------------------------------------------------------------------------ def self.can_skill_normal?(skill_id) return false unless SKILL_NORMAL_FLASH return false if NOT_FLASH_SKILL.include?(skill_id) return false if ONLY_DERIVE_SKILL.include?(skill_id) return true end #------------------------------------------------------------------------ # ● エネミー閃き可能？ #------------------------------------------------------------------------ def self.can_enemy?(battler, flag) return false unless flag return battler.enemy? end ################################################################################ #-------------------------------------------------------------------------- # ● 通常攻撃時の閃き判定(前処理) #-------------------------------------------------------------------------- def self.normal_flash(battler) return 0 unless can_flash?(battler) return sys_flash_main(TYPE_NORMAL, battler) if NORMAL_FLASH and battler.actor? return sys_flash_main(TYPE_ENEMY, battler) if can_enemy?(battler, ENEMY_NORMAL) return 0 end #-------------------------------------------------------------------------- # ● スキル使用時の閃き判定(前処理) #-------------------------------------------------------------------------- def self.skill_flash(battler) return 0 unless can_flash?(battler) return skill_flash_actor(battler) if battler.actor? return sys_flash_main(TYPE_ENEMY, battler) if can_enemy?(battler, ENEMY_SKILL) return 0 end #-------------------------------------------------------------------------- # ● スキル使用時の閃き判定(前処理) : actor #-------------------------------------------------------------------------- def self.skill_flash_actor(battler) if !battler.current_action.item.nil? and can_derive?(battler.current_action.item.id) return skill_flash_derive(battler) end return sys_flash_main(TYPE_NORMAL, battler) end #-------------------------------------------------------------------------- # ● スキル使用時の閃き判定(前処理) : actor #-------------------------------------------------------------------------- def self.skill_flash_derive(battler) skill_id = battler.current_action.item.id # 使用回数カウント(使用回数を使用する場合のみ) battler.skill_count(skill_id) if DEREIVE_USE # 派生閃きメイン処理へ new_skill_id = sys_flash_main(TYPE_DERIVE, battler) if battler.flash_flg # 閃き成功 # スキルから閃いた場合、スキル使用回数のカウントはしない battler.skill_recount(skill_id) if DEREIVE_USE # スキル使用時通常閃き：スキル派生閃き失敗時に適応される elsif can_skill_normal?(skill_id) new_skill_id = sys_flash_main(TYPE_NORMAL, battler) if battler.flash_flg # 閃き成功 # スキルから閃いた場合、スキル使用回数のカウントはしない battler.skill_recount(skill_id) if DEREIVE_USE end end return new_skill_id end #-------------------------------------------------------------------------- # ● 閃きシステム メイン処理 #-------------------------------------------------------------------------- def self.sys_flash_main(type, battler) # 閃き対象のスキル群を取得 case type when TYPE_NORMAL; f_skill = divide_normal(battler) when TYPE_DERIVE; f_skill = divide_derive(battler, battler.current_action.item.id) when TYPE_ENEMY; f_skill = divide_enemy(battler) else; return 0 end return if f_skill.nil? or !f_skill.can_flash # 対象なし #~ p "last judge id:#{f_skill.skill_id}" # 閃き判定 if battler.actor? battler.learn_skill(f_skill.skill_id) # 一旦、習得させる unless jugde_flash(battler, f_skill) battler.forget_skill(f_skill.skill_id) # スキル忘却 return 0 end else # 既に閃き済みでもスキル行動ならそのまま発動させる return f_skill.skill_id if battler.skill_learn?($data_skills[f_skill.skill_id]) return 0 unless jugde_flash(battler, f_skill) # 使えない場合は却下 battler.learn_skill(f_skill.skill_id) # 習得させる end battler.flash_success # 閃き発動 #~ p "flash!! id:#{f_skill.skill_id}" return f_skill.skill_id end #-------------------------------------------------------------------------- # ● 確率計算(rand) #-------------------------------------------------------------------------- def self.clac_rand(n) rand(n*100) * 1.0 / 100.0 end #-------------------------------------------------------------------------- # ● 閃き率上昇 [強敵/弱敵] #-------------------------------------------------------------------------- def self.add_prob_diff_lv(battler) return 0 unless USE_DIF_LV_UP return 0 unless defined?(Enemy_Level) return clac_diff_prob(battler.level, $game_troop) if battler.actor? return clac_diff_prob(battler.level, $game_party) if battler.enemy? return 0 end def self.clac_diff_prob(attacker_lv, unit) members = unit.alive_members diffenders_lv = members.inject(0) {|lv, e| lv + e.level } / members.size return 0 if !USE_DIF_LV_DW and (attacker_lv > diffenders_lv) diff = diffenders_lv - attacker_lv dir = diff == 0 ? 1 : diff / diff.abs diff = diff.abs return (DIF_LV_UP[0] * dir) if diff <= 5 return (DIF_LV_UP[1] * dir) if diff <= 10 return (DIF_LV_UP[2] * dir) if diff <= 20 return (DIF_LV_UP[3] * dir) if diff <= 30 return (DIF_LV_UP[4] * dir) if diff <= 40 return (DIF_LV_UP[5] * dir) if diff <= 50 return (DIF_LV_UP[6] * dir) end #-------------------------------------------------------------------------- # ● 閃き率上昇 [ピンチ] #-------------------------------------------------------------------------- def self.add_prob_pinch(battler) return 0 unless USE_PINCH_UP # ピンチのときは閃き率上昇 return PINCH_PRO_UP[0] if battler.hp <= (battler.mhp / 10) return PINCH_PRO_UP[1] if battler.hp <= (battler.mhp / 4) return PINCH_PRO_UP[2] if battler.hp <= (battler.mhp / 2) return PINCH_PRO_UP[4] if battler.hp == battler.mhp return PINCH_PRO_UP[3] end #-------------------------------------------------------------------------- # ● 閃き率減算 [スキル数] #-------------------------------------------------------------------------- def self.sub_prob_skillnum(battler) return 0 unless USE_SKILL_NUM return 0 unless battler.actor? n = battler.skills.size return clac_rand(SKN_RATE[0]) if n <= 10 return clac_rand(SKN_RATE[1]) if n <= 20 return clac_rand(SKN_RATE[2]) if n <= 30 return clac_rand(SKN_RATE[3]) if n <= 40 return clac_rand(SKN_RATE[4]) if n <= 50 return clac_rand(SKN_RATE[5]) end #-------------------------------------------------------------------------- # ● 閃き率上昇 [レベル] #-------------------------------------------------------------------------- def self.add_prob_level(battler) return 0 unless USE_LV_UP return 0 if battler.enemy? and !defined?(Enemy_Level) l = battler.level return clac_rand(LVUP_RATE[0]) if l <= 10 return clac_rand(LVUP_RATE[1]) if l <= 20 return clac_rand(LVUP_RATE[2]) if l <= 30 return clac_rand(LVUP_RATE[3]) if l <= 40 return clac_rand(LVUP_RATE[4]) if l <= 50 return clac_rand(LVUP_RATE[5]) end #-------------------------------------------------------------------------- # ● 閃き率上昇 [熟練度] #-------------------------------------------------------------------------- def self.add_prob_attr_grow(battler, flash) return 0 unless battler.actor? return 0 unless defined?(SysUpdate) # 熟練度システムがある場合のみ prob = 0 # 攻撃属性が得意・不得意かによって確率を変動させる if USE_ATK_ATTR_UP and !battler.current_action.item.nil? prob += clac_attr_taste(battler, battler.current_action.item) end # 閃き対象の攻撃属性が得意・不得意かによって確率を変動させる prob += clac_attr_taste(battler, $data_skills[flash.skill_id]) if USE_FLASH_ATTR_UP return prob end def self.clac_attr_taste(battler, elements) return 0 unless defined?(SysUpdate) # 熟練度システムがある場合のみ prob = 0 SysUpdate.elements(battler, elements).each do |attr_id| if SysUpdate::ELEMENTS.include?(attr_id) attr = battler.attr[attr_id] prob += (ATTR_PRO_UP * attr.level) if attr.is_good_taste? prob -= (ATTR_PRO_UP * attr.level) if attr.is_bad_taste? end end return prob end #------------------------------------------------------------------------- # ● 閃き率上昇 [装備] : 全部増減 #------------------------------------------------------------------------- def self.flash_all_updown(item) result = item.note.scan(/@f_a_ud\[(.*?+)\]/) return 0 if result.nil? or result.empty? return result[0][0].to_i end #------------------------------------------------------------------------- # ● 閃き率上昇 [装備] : 対象スキルIDだけ増減 #------------------------------------------------------------------------- def self.flash_skill_updown(item, skill_id) result = item.note.scan(/@f_s_ud\[(\d+),(.*?+)\]/) return 0 if result.nil? or result.empty? result.each do |n| return n[1].to_i if n[0].to_i == skill_id end return 0 end #------------------------------------------------------------------------- # ● 閃き率上昇 [装備] : 対象スキルタイプだけ増減 #------------------------------------------------------------------------- def self.flash_stype_updown(item, skill_type) result = item.note.scan(/@f_t_ud\[(\d+),(.*?+)\]/) return 0 if result.nil? or result.empty? result.each do |n| return n[1].to_i if n[0].to_i == skill_type end return 0 end #------------------------------------------------------------------------- # ● 閃き率上昇 [装備] : 同じ武器タイプならば増減 #------------------------------------------------------------------------- def self.flash_wtype_updown(item, battler, skill) return 0 unless item.is_a?(RPG::Weapon) return 0 unless battler.skill_wtype_ok?(skill) result = item.note.scan(/@f_w_ud\[(.*?+)\]/) return 0 if result.nil? or result.empty? return result[0][0].to_i end #-------------------------------------------------------------------------- # ● 閃き率上昇 [装備] #-------------------------------------------------------------------------- def self.add_prob_equip(battler, flash) return 0 unless USE_EQUIP_UP return 0 unless battler.actor? r = 0 battler.equips.compact.each do |equip| r += flash_all_updown(equip) r += flash_skill_updown(equip, flash.skill_id) r += flash_stype_updown(equip, flash.skill.stype_id) r += flash_wtype_updown(equip, battler, flash.skill) end return r end #-------------------------------------------------------------------------- # ● 閃き判定 ：確率判定 #-------------------------------------------------------------------------- def self.jugde_flash(battler, flash) # 確率上昇/下降計算 flash.prob += add_prob_attr_grow(battler, flash) flash.prob += add_prob_diff_lv(battler) flash.prob += add_prob_pinch(battler) flash.prob -= sub_prob_skillnum(battler) flash.prob += add_prob_equip(battler, flash) flash.prob += add_usr_prob(battler, flash.skill) return flash.exe_prob # 最終判定 end #---------------------------------------------------------------------------- # ■ 通常閃き #---------------------------------------------------------------------------- #------------------------------------------------------------------------ # ● ベースクラス #------------------------------------------------------------------------ class FlashBase #---------------------------------------------------------------------- # ● オブジェクト初期化 #---------------------------------------------------------------------- def initialize(battler) @battler = battler end #-------------------------------------------------------------------------- # ● スキルの使用可能条件チェック # Game_BattlerBase#skill_conditions_met? からコスト以外を判定 #-------------------------------------------------------------------------- def flash_can_use?(skill) @battler.usable_item_conditions_met?(skill) && @battler.skill_wtype_ok?(skill) && #skill_cost_payable?(skill) && !@battler.skill_sealed?(skill.id) && !@battler.skill_type_sealed?(skill.stype_id) end #---------------------------------------------------------------------- # ● 閃き済み判定 #---------------------------------------------------------------------- def flash_skill_learn?(skill) learn = @battler.skill_learn?(skill) # エネミーの場合習得済みスキルは通常スキルとして発動さえるのでコスト計算 return learn && @battler.skill_cost_payable?(skill) unless @battler.actor? return learn end #---------------------------------------------------------------------- # ● ターゲット選択の判定 #---------------------------------------------------------------------- def target_can_include?(org_skill, new_skill) # ダメージ対象が異なる場合は含まない return false if org_skill.damage.type != new_skill.damage.type return false if org_skill.for_opponent? != new_skill.for_opponent? return false if org_skill.for_friend? != new_skill.for_friend? return false if org_skill.for_dead_friend? != new_skill.for_dead_friend? return false if org_skill.for_user? != new_skill.for_user? # 複数 -> 単体は許可しない return false if org_skill.for_all? and new_skill.for_one? # 複数 -> ランダムは許可しない return false if org_skill.for_all? and new_skill.for_random? # ランダム -> 単体は許可しない return false if org_skill.for_random? and new_skill.for_one? # 選択が必要になる場合は許可しない return false if !org_skill.need_selection? and new_skill.need_selection? return true end #---------------------------------------------------------------------- # ● 威力の判定 <非推奨> #---------------------------------------------------------------------- def damage_can_include?(org_skill, new_skill) return true unless DISABLE_PW_DOWN return true if org_skill.damage.type == 0 return true if new_skill.damage.type == 0 # 自分to自分で計算する…。 org_damage = org_skill.damage.eval(@battler, @battler, $game_variables) new_damage = new_skill.damage.eval(@battler, @battler, $game_variables) return (org_damage <= new_damage) end #---------------------------------------------------------------------- # ● 威力の判定(コストで判断) #---------------------------------------------------------------------- def cost_can_include?(org_skill, new_skill) return true unless DISABLE_COST_DOWN return clac_cost_max(org_skill) <= clac_cost_max(new_skill) end def clac_cost_max(skill) skill.mp_cost > skill.tp_cost ? skill.mp_cost : skill.tp_cost end #---------------------------------------------------------------------- # ● 属性の判定 #---------------------------------------------------------------------- def element_can_include?(org_skill, new_skill) return true unless ONLY_SAME_ELEMENT return true if org_skill.damage.element_id == 0 return true if new_skill.damage.element_id == 0 return true if UNCHECK_ELEMENTS.inluce?(org_skill.damage.element_id) return true if UNCHECK_ELEMENTS.inluce?(new_skill.damage.element_id) return org_skill.damage.element_id == new_skill.damage.element_id end #---------------------------------------------------------------------- # ● 閃き対象に含めるかを判断 #---------------------------------------------------------------------- def base_can_include?(org_skill, new_skill) return false unless target_can_include?(org_skill, new_skill) return false unless damage_can_include?(org_skill, new_skill) return false unless element_can_include?(org_skill, new_skill) return true end #---------------------------------------------------------------------- # ● 熟練度による閃き制限 #---------------------------------------------------------------------- def attr_level_limitter(skill_id) return false unless @battler.actor? if defined?(SysUpdate) and USE_ATTR_LV_LIMITTER return false if ATTR_LIMIT_SKILL[skill_id].nil? attrs = [] ATTR_LIMIT_SKILL[skill_id].each do |a| attr = SysUpdate::Attr.new attr.id = a[0] attr.level = a[1] attrs.push(attr) end return attrs.any? {|a| a.level > @battler.attr[a.id].level} end return false end #---------------------------------------------------------------------- # ● 閃き対象判定 #---------------------------------------------------------------------- def can_include?(skill_id) skill = $data_skills[skill_id] return false if flash_skill_learn?(skill) return false unless flash_can_use?(skill) return false if attr_level_limitter(skill_id) return false if @battler.current_action.item.nil? return base_can_include?(@battler.current_action.item, skill) end end #------------------------------------------------------------------------ # ● 設定情報をクラス化 通常閃き & エネミー閃き 共通処理 #------------------------------------------------------------------------ class NormalFlash < FlashBase #---------------------------------------------------------------------- # ● オブジェクト初期化 #---------------------------------------------------------------------- def initialize(battler, data) super(battler) @set = [] data.each do |d| @set.push(NormalFlashData.new(d)) if can_include?(d[0]) end end #---------------------------------------------------------------------- # ● レーティング計算 #---------------------------------------------------------------------- def rating_rand(data) idxs = [] data.each_index do |i| data[i].rating.times { |j| idxs.push(i)} end return nil if idxs.empty? data[idxs[rand(idxs.size)]] end #---------------------------------------------------------------------- # ● ランダム抽出 #---------------------------------------------------------------------- def randum_set rating_rand(@set) end #---------------------------------------------------------------------- # ● データ構造クラス(DeriveFlashと同IF) #---------------------------------------------------------------------- class NormalFlashData attr_accessor:prob # 確率 attr_reader :skill_id # スキルID attr_reader :can_flash # 閃き可能？ attr_reader :rating # レーティング #-------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------- def initialize(data) @skill_id = data[0] @prob = data[1] @rating = data[2].nil? ? 1 : data[2] @can_flash = true end #-------------------------------------------------------------------- # ● スキルObject #-------------------------------------------------------------------- def skill $data_skills[@skill_id] end #-------------------------------------------------------------------- # ● 確率計算 #-------------------------------------------------------------------- def exe_prob return rand(10000)/100.0 < @prob end end end #---------------------------------------------------------------------------- # ■ Flash System　スキル派生版 #---------------------------------------------------------------------------- #------------------------------------------------------------------------ # ● 設定情報をクラス化 スキル派生 (NormalFlashDataと同IF) #------------------------------------------------------------------------ class DeriveFlash < FlashBase attr_accessor:prob # 確率 attr_reader :skill_id # スキルID attr_reader :can_flash # 閃き可能？ def initialize(battler, data, skill_id) super(battler) @use_skill_id = skill_id set_data = data.select {|d| can_include?(d[2], d[1])} if set_data.empty? @can_flash = false else @can_flash = true rand_set = rating_rand(set_data) @prob = rand_set[0] @skill_id = rand_set[2] end end #---------------------------------------------------------------------- # ● スキルObject #---------------------------------------------------------------------- def skill @can_flash ? $data_skills[@skill_id] : nil end #---------------------------------------------------------------------- # ● レーティング計算 #---------------------------------------------------------------------- def rating_rand(data) idxs = [] data.each_index {|i| data[i][3].times { |j| idxs.push(i)} } data[idxs[rand(idxs.size)]] end #---------------------------------------------------------------------- # ● 閃き対象判定 #---------------------------------------------------------------------- def can_include?(skill_id, condition) return false unless super(skill_id) return true if condition.nil? # 条件なし condition.all? {|skill_id| @battler.skill_learn?($data_skills[skill_id])} end #---------------------------------------------------------------------- # ● 確率計算 #---------------------------------------------------------------------- def exe_prob return (DEREIVE_USE ? (@battler.skill_use[@use_skill_id] < @prob) : (rand(10000)/100.0 < @prob) ) end end #---------------------------------------------------------------------------- # ■ エネミー閃き #---------------------------------------------------------------------------- #-------------------------------------------------------------------------- # ● エネミー 対象振り分け #-------------------------------------------------------------------------- def self.divide_enemy(enemy) flash_skills = E_FLASH[enemy.enemy_id] # 空定義は無視する。 return nil if flash_skills.nil? or flash_skills.empty? # 閃き対象がある場合はクラス化して返す return NormalFlash.new(enemy, flash_skills.dup).randum_set end end #============================================================================== # ■ Game_BattlerBase #============================================================================== class Game_BattlerBase attr_accessor :flash_flg # 閃きフラグ attr_accessor :multi_flash_flg # 閃きフラグ[複数行動] #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- alias sys_flash_initialize initialize def initialize sys_flash_initialize @flash_flg = false @multi_flash_flg = false end #-------------------------------------------------------------------------- # ● 閃き成功 #-------------------------------------------------------------------------- def flash_success @flash_flg = @multi_flash_flg = true end #-------------------------------------------------------------------------- # ● 閃きフラグクリア #-------------------------------------------------------------------------- def flash_clear(one=false) @flash_flg = false @multi_flash_flg = one && @multi_flash_flg end #-------------------------------------------------------------------------- # ● スキルの消費 MP 計算 #-------------------------------------------------------------------------- alias skill_mp_cost_flash skill_mp_cost def skill_mp_cost(skill) return 0 if SysFlash::FLASH_COST and self.flash_flg return skill_mp_cost_flash(skill) end #-------------------------------------------------------------------------- # ● スキルの消費 TP 計算 #-------------------------------------------------------------------------- alias skill_tp_cost_flash skill_tp_cost def skill_tp_cost(skill) return 0 if SysFlash::FLASH_COST and self.flash_flg skill_tp_cost_flash(skill) end end #============================================================================== # ■ Game_Battler #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # ● 戦闘行動終了時の処理 #-------------------------------------------------------------------------- alias on_action_end_sysflash on_action_end def on_action_end flash_clear on_action_end_sysflash end end #============================================================================== # ■ Game_Actor #============================================================================== # スキル使用回数を使用する場合のみ有効。スキル派生なしなら不要パラメータ if SysFlash::DEREIVE_USE and SysFlash::DERIVE_FLASH class Game_Actor < Game_Battler attr_accessor :skill_use # スキル使用回数 #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- alias sys_flash_init initialize def initialize(actor_id) sys_flash_init(actor_id) @skill_use = [] end #-------------------------------------------------------------------------- # ● スキル使用回数カウント #-------------------------------------------------------------------------- def skill_count(skill_id) @skill_use[skill_id] = @skill_use[skill_id].nil? ? 1 : @skill_use[skill_id] + 1 end #-------------------------------------------------------------------------- # ● スキル使用回数カウント補正 #-------------------------------------------------------------------------- def skill_recount(skill_id) @skill_use[skill_id] = @skill_use[skill_id].nil? ? 0 : (@skill_use[skill_id] == 0 ? 0 : @skill_use[skill_id] - 1) end end end # SysFlash::DEREIVE_USE and SysFlash::DERIVE_FLASH #============================================================================== # ■ Game_Enemy #============================================================================== class Game_Enemy < Game_Battler attr_reader :skills # スキル #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- alias sys_flash_init initialize def initialize(index, enemy_id) sys_flash_init(index, enemy_id) @skills = $data_enemies[enemy_id].actions.collect { |a| a.skill_id } end #-------------------------------------------------------------------------- # ● スキルを覚える #-------------------------------------------------------------------------- def learn_skill(skill_id) unless skill_learn?($data_skills[skill_id]) @skills.push(skill_id) @skills.sort! end end #-------------------------------------------------------------------------- # ● スキルの習得済み判定 #-------------------------------------------------------------------------- def skill_learn?(skill) @skills.include?(skill.id) end end class Game_Action #-------------------------------------------------------------------------- # ● 行動準備 #-------------------------------------------------------------------------- alias prepare_sysflash prepare def prepare prepare_sysflash execute_flash if !subject.confusion? && !forcing end #-------------------------------------------------------------------------- # ● 防御判定 #-------------------------------------------------------------------------- def guard? item == $data_skills[subject.guard_skill_id] end #-------------------------------------------------------------------------- # ● アイテム判定 #-------------------------------------------------------------------------- def item? item.is_a?(RPG::Item) end #-------------------------------------------------------------------------- # ● 閃き処理 #-------------------------------------------------------------------------- def execute_flash return if item? or guard? @subject.flash_flg = false new_skill_id = attack? ? SysFlash.normal_flash(@subject) : SysFlash.skill_flash(@subject) set_skill(new_skill_id) if @subject.flash_flg self end end class Window_BattleLog < Window_Selectable #-------------------------------------------------------------------------- # ● スキル／アイテム使用の表示 #-------------------------------------------------------------------------- alias display_use_item_sysflash display_use_item def display_use_item(subject, item) if subject.flash_flg and item.is_a?(RPG::Skill) SysFlash::FLASH_SE.play unless SysFlash::FLASH_SE.nil? add_text(subject.name + "は" + item.name + "を閃いた！") else display_use_item_sysflash(subject, item) end end end class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # ● 閃きアニメーションの表示 #-------------------------------------------------------------------------- def show_flash_animation return unless SysFlash::FLASH_ANIME and @subject.flash_flg show_normal_animation([@subject], SysFlash::FLASH_ANIMATION_ID) wait_for_animation end #-------------------------------------------------------------------------- # ● 戦闘行動の実行 #-------------------------------------------------------------------------- alias execute_action_sysflash execute_action def execute_action show_flash_animation execute_action_sysflash @subject.flash_clear(true) # not multi end end