#============================================================================== # ■統合ベーススクリプトＣ for RGSS3 Ver2.21-β2 #　□作成者 kure # #　戦闘計算処理に関するスクリプト群です。 # #============================================================================== p "統合ベーススクリプトＣ" #拡張特徴の取得とダメージ計算関するスクリプト処理群---------------------------- #============================================================================== # ■ Game_Temp #============================================================================== class Game_Temp attr_accessor :first_invoke # 特殊発動 end #============================================================================== # ■ Game_BattlerBase #============================================================================== class Game_BattlerBase #-------------------------------------------------------------------------- # ◎ スキル／アイテムの使用可能判定(エイリアス) #-------------------------------------------------------------------------- alias :k_integrate_before_usable? :usable? unless $! def usable?(item) return equip_item_conditions_met?(item) if item.is_a?(RPG::EquipItem) k_integrate_before_usable?(item) end #-------------------------------------------------------------------------- # ● 装備アイテムの使用可能条件チェック #-------------------------------------------------------------------------- def equip_item_conditions_met?(item) movable? && $game_party.has_item?(item) && equip_occasion_ok?(item) end #-------------------------------------------------------------------------- # ● 装備アイテムの使用可能時チェック #-------------------------------------------------------------------------- def equip_occasion_ok?(item) return true if item.occasion == 0 return true if item.occasion == 1 && $game_party.in_battle return true if item.occasion == 2 && !$game_party.in_battle return false end #-------------------------------------------------------------------------- # □ スキル使用コストの支払い可能判定(再定義) #-------------------------------------------------------------------------- def skill_cost_payable?(skill) return false if tp < skill_tp_cost(skill) return false if mp < skill_mp_cost(skill) return false if hp < skill_hp_cost(skill) return true unless actor? #アクターの場合の追加判定 return false unless skill_item_cost_payable?(skill) return false if $game_party.gold < skill.gold_cost * double_cost(skill, 3) return true end #-------------------------------------------------------------------------- # ◎ スキル使用コストの支払い(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_pay_skill_cost :pay_skill_cost unless $! def pay_skill_cost(skill) k_integrate_before_pay_skill_cost(skill) self.hp = [self.hp - skill_hp_cost(skill),1].max if actor? pay_skill_item_cost(skill) $game_party.lose_gold(skill.gold_cost * double_cost(skill, 3)) end if skill.delay && skill.is_a?(RPG::Skill) data = skill.delay data[0] = [data[0] + delay_revise, 1].max @ad_counter[5].push(data) end @ad_counter[5].push(skill.delay_infinity) if skill.delay_infinity && skill.is_a?(RPG::Skill) delay_counter(skill.delay_change) end #-------------------------------------------------------------------------- # □ スキルの消費 MP 計算(再定義) #-------------------------------------------------------------------------- def skill_mp_cost(skill) result = [skill.mp_cost + type_add(0, skill.stype_id) + skill_e_cost_a(0, skill), 0].max result += mp * (skill.mp_cost_ex[0].to_f / 100) result += mmp * (skill.mp_cost_ex[1].to_f / 100) result *= double_cost(skill, 0) return (result * mcr * typer(0, skill.stype_id) * skill_e_cost_r(0, skill)).to_i end #-------------------------------------------------------------------------- # □ スキルの消費 TP 計算(再定義) #-------------------------------------------------------------------------- def skill_tp_cost(skill) result = [skill.tp_cost + type_add(1, skill.stype_id) + skill_e_cost_a(1, skill), 0].max result += tp * (skill.tp_cost_ex[0].to_f / 100) result += max_tp * (skill.tp_cost_ex[1].to_f / 100) result *= double_cost(skill, 1) return (result * tpr * typer(1, skill.stype_id) * skill_e_cost_r(1, skill)).to_i end #-------------------------------------------------------------------------- # ★ スキルの消費 HP 計算(追加定義) #-------------------------------------------------------------------------- def skill_hp_cost(skill) result = [skill.hp_cost[0] + type_add(2, skill.stype_id) + skill_e_cost_a(2, skill), 0].max result += hp * (skill.hp_cost[1].to_f / 100) result += mhp * (skill.hp_cost[2].to_f / 100) result *= double_cost(skill, 2) return (result * hpr * typer(2, skill.stype_id) * skill_e_cost_r(2, skill)).to_i end #-------------------------------------------------------------------------- # ★ 属性コスト乗算の計算(追加定義) #-------------------------------------------------------------------------- def skill_e_cost_r(type, skill) cost_r = 1 element = skill.damage.element_id > 0 ? [skill.damage.element_id] : [] element += skill.reflect_elements element.each{|id| cost_r *= cost_e_rate(type, id)} return cost_r end #-------------------------------------------------------------------------- # ★ 属性コスト加算の計算(追加定義) #-------------------------------------------------------------------------- def skill_e_cost_a(type, skill) cost_a = 0 element = skill.damage.element_id > 0 ? [skill.damage.element_id] : [] element += skill.reflect_elements element.each{|id| cost_a += cost_e_add(type, id)} return cost_a end #-------------------------------------------------------------------------- # ★ スキルの消費アイテムチェック(追加定義) #-------------------------------------------------------------------------- def skill_item_cost_payable?(skill) return true unless actor? skill.need_items.each{|block| item_data = KURE.item_obj(block[0], block[1]) next if $game_party.item_number(item_data) >= block[2] * double_cost(skill, 4) return false } return true end #-------------------------------------------------------------------------- # ★ スキルの消費倍率を返す(追加定義) #-------------------------------------------------------------------------- def double_cost(item,id) return 1 if !dual_wield? value = item.dual_cost.collect{|block| block[1] if block[0] == id} value.compact! return value != [] ? value.max : 1 end #-------------------------------------------------------------------------- # ★ スキルの消費アイテムチェック(追加定義) #-------------------------------------------------------------------------- def pay_skill_item_cost(skill) skill.need_items.each{|block| $game_party.lose_item(KURE.item_obj(block[0], block[1]),block[2] * double_cost(skill, 4))} end #-------------------------------------------------------------------------- # ● 制約の取得(エイリアス) #-------------------------------------------------------------------------- alias :k_integrate_before_restriction :restriction unless $! def restriction value1 = k_integrate_before_restriction value2 = auto_states_ex_obj.collect {|state| state.restriction }.push(0).max return [value1, value2].max end end #============================================================================== # ■ Game_Battler #============================================================================== class Game_Battler < Game_BattlerBase #拡張特徴レート計算処理---------------------------------------------------- #-------------------------------------------------------------------------- # ★拡張特徴共通処理1(レート計算処理)(追加定義) #-------------------------------------------------------------------------- def common_task_1(id, data_id, base_value) add_features_object(id)[data_id] ? add_features_object(id)[data_id] : base_value end #-------------------------------------------------------------------------- # ★拡張特徴共通処理2(レート計算処理)(値チェック処理) #-------------------------------------------------------------------------- def common_task_2(id, base_value) add_features_object(id) ? add_features_object(id) : base_value end #-------------------------------------------------------------------------- # ★拡張特徴共通処理3(反撃率計算処理) #-------------------------------------------------------------------------- def common_task_3(id, item, e_list, base_value) value = base_value data = add_features_object(id) #反撃率を加算 e_list.each{|e_id| value += data[item.hit_type][e_id] if data[item.hit_type][e_id] value += data[3][e_id] if data[3][e_id] value += data[item.hit_type][0] if data[item.hit_type][0] value += data[3][0] if data[3][0] value += cnt if id == 30 && item.hit_type == 1 } return value end #拡張特徴の取得処理(単純取得が可能なもの)---------------------------------- #-------------------------------------------------------------------------- # ★ 拡張特徴の取得 #-------------------------------------------------------------------------- def element_gain_rate(id) ; common_task_1(1, id, 1.0) ; end #ID1(属性強化) def element_add_rate(id) ; common_task_1(2, id, 0.0) ; end #ID2(属性追加) def element_drain_rate(id) ; common_task_1(3, id, 0.0) ; end #ID3(属性吸収) def hit_type_gain_rate(id) ; common_task_1(4, id, 1.0) ; end #ID4(命中強化) def hit_type_add_rate(id) ; common_task_1(5, id, 0.0) ; end #ID5(命中追加) def hit_type_drain_rate(id) ; common_task_1(6, id, 0.0) ; end #ID6(命中吸収) def normal_attack_gain_rate ; add_features_object(7) ; end #ID7(通常攻撃強化) def normal_attack_drain_rate ; add_features_object(8) ; end #ID8(通常攻撃吸収) def skill_type_gain_rate(id) ; common_task_1(9, id, 1.0) ; end #ID9(スキルタイプ強化) def skill_type_drain_rate(id) ; common_task_1(10, id, 0.0) ; end #ID10(スキルタイプ吸収) def state_gain_rate(id) ; common_task_1(11, id, 1.0) ; end #ID11(ステート強化) def state_add_rate(id) ; common_task_1(12, id, 0.0) ; end #ID12(ステート追加) def state_drain_rate(id) ; common_task_1(13, id, 0.0) ; end #ID13(ステート耐性) def weapon_gain_rate(id) ; common_task_1(14, id, 1.0) ; end #ID14(武器タイプ強化) def recover_gain_rate(id) ; common_task_1(15, id, 1.0) ; end #ID15(回復強化) def recover_add_rate(id) ; common_task_1(16, id, 0.0) ; end #ID16(属性追加) def recover_drain_rate(id) ; common_task_1(17, id, 0.0) ; end #ID17(属性吸収) def critiacal_gain_rate ; add_features_object(18) ; end #ID18(会心強化) def critiacal_rate ; add_features_object(19) ; end #ID19(会心有効度) def critiacal_add_rate ; add_features_object(20) ; end #ID20(会心追加) def critiacal_drain_rate ; add_features_object(21) ; end #ID21(会心耐性) def adversity_cut_rate ; add_features_object(22) ; end #ID22(逆境補正) def damage_limit_value ; add_features_object(23) ; end #ID23(ダメージ上限) def invalidate_wall ; add_features_object(24) ; end #ID24(ダメージ無効化) def hit_type_invalidate ; add_features_object(25) ; end #ID25(命中タイプ無効化) def defence_wall ; add_features_object(26) ; end #ID26(ダメージ減少) def auto_stand ; add_features_object(27) ; end #ID27(踏み止まり) def auto_list ; add_features_object(28) ; end #ID28(オートステート) def auto_list_ex ; common_task_2(29, []) ; end #ID29(完全オートステート) def normal_cnt_rate(i, e) ; common_task_3(30, i, e, 0.0); end #ID30(通常反撃率) def target_element ; add_features_object(31) ; end #ID31(優先対象) def damage_convert ; add_features_object(32) ; end #ID32(ダメージ変換) def damage_collect ; add_features_object(33) ; end #ID33(ダメージ回収) def counter_skill_id_list ; add_features_object(34) ; end #ID34(反撃スキル) def counter_break_obj ; add_features_object(35) ; end #ID35(反撃無効化) def counter_attack_gain_rate ; add_features_object(36) ; end #ID36(反撃強化) def counter_attack_drain_rate ; add_features_object(37) ; end #ID37(反撃耐性) def adv_cnt_rate(i, e) ; common_task_3(38, i, e, 0.0); end #ID38(拡張反撃) def eva_cnt_rate(i, e) ; common_task_3(39, i, e, 0.0); end #ID39(回避反撃) def counter_states ; add_features_object(40) ; end #ID40(反撃ステート) def final_skill_id_list ; add_features_object(41) ; end #ID41(最終反撃) def sub_cnt_rate(i, e) ; common_task_3(42, i, e, 0.0); end #ID42(身代わり反撃) def change_item_obj ; add_features_object(43) ; end #ID43(スキル変化) def change_action_obj ; add_features_object(44) ; end #ID44(行動変化) def cer_rf_rate ; add_features_object(45) ; end #ID45(必中反撃) def phy_rf_rate ; add_features_object(46) ; end #ID46(魔法反撃率) def reflection_gain_rate ; add_features_object(47) ; end #ID47(反射強化) def reflection_drain_rate ; add_features_object(48) ; end #ID48(反射耐性) def reflection_break_obj ; add_features_object(49) ; end #ID49(反射無効化) def state_change_obj ; add_features_object(50) ; end #ID50(ステート転換) def counter_state_break_obj ; add_features_object(52) ; end #ID52(反撃ステート無効化) def react_obj ; add_features_object(53) ; end #ID53(行動反応追撃) def after_healing ; add_features_object(54) ; end #ID54(戦闘後回復) def tp_revise ; add_features_object(56) ; end #ID56(最大TP変化) def tpr ; add_features_object(57) ; end #ID57(TP消費率) def hpr ; add_features_object(58) ; end #ID58(HP消費率) def reverse_deth ; add_features_object(60) ; end #ID60(即死反転率) def steal_rate ; add_features_object(61) ; end #ID61(スティール成功率) def invalidate_def_wall ; add_features_object(62) ; end #ID62(防御壁展開) def react_break_obj ; add_features_object(63) ; end #ID63(追撃無効化) def auto_revive ; add_features_object(64) ; end #ID64(自動復活) def trigger_state ; add_features_object(65) ; end #ID65(トリガーステート) def delay_state ; add_features_object(66) ; end #ID66(ディレイステート) def special_chase ; add_features_object(67) ; end #ID67(特殊発動) def resist_life_obj ; add_features_object(68) ; end #ID68(自爆耐性) def encount_rate ; add_features_object(69) ; end #ID69(エンカウント率) def drop_rate ; add_features_object(70) ; end #ID70(ドロップ率) def gold_rate ; add_features_object(71) ; end #ID71(獲得金額率) def durable_rate ; add_features_object(73) ; end #ID73(耐久値減少率取得) def gain_drop_rate ; add_features_object(74) ; end #ID74(ドロップ率増加) def spread_element_obj ; add_features_object(76) ; end #ID76(属性場変動値) def scope_type_gain_rate(id) ; common_task_1(77, id, 1.0) ; end #ID77(効果範囲強化) def scope_type_add_rate(id) ; common_task_1(78, id, 0.0) ; end #ID78(効果範囲追加) def scope_type_drain_rate(id) ; common_task_1(79, id, 0.0) ; end #ID78(効果範囲吸収) def gain_gold_rate ; add_features_object(80) ; end #ID89(獲得額増加) def delay_revise ; add_features_object(81) ; end #ID81(ディレイ変化) def ability_list ; add_features_object(83) ; end #ID81(AP制スキル習得能力) def element_react_state ; add_features_object(84) ; end #ID84(属性反応ステート) def mhit ; add_features_object(85) ; end #ID85(魔法命中率) def change_self_react ; add_features_object(90) ; end #ID90(反動変化) def level_bonus_revise ; add_features_object(94) ; end #ID94(レベル上昇補正) def convert_skill_obj ; add_features_object(96) ; end #ID96(スキル変換) def convert_item_obj ; add_features_object(97) ; end #ID97(アイテム変換) def hit_type_change ; add_features_object(98) ; end #ID98(命中タイプ指定) def reflection_dmg_obj ; add_features_object(99) ; end #ID99(ダメージ反射) def reflection_dmg_rate ; add_features_object(100) ; end #ID100(ダメージ反射有効度) def reflection_dmg_gain_rate ; add_features_object(101) ; end #ID101(ダメージ反射強化) def reflection_dmg_add_rate ; add_features_object(102) ; end #ID102(ダメージ反射追加) def reflection_dmg_drain_rate ; add_features_object(103) ; end #ID103(ダメージ反射耐性) def ignore_rec_rate ; add_features_object(104) ; end #ID104(回復効果率無視) def var_revise ; add_features_object(105) ; end #ID105(分散度変化) def ignore_state_rate_ft ; add_features_object(106) ; end #ID106(ステート有効度無視) def pierce_obj ; add_features_object(107) ; end #ID107(貫通技能) #拡張特徴取得(個別計算処理)------------------------------------------------ #連続及び特殊発動--------------------------------------------------------- #-------------------------------------------------------------------------- # ★ 連続発動オブジェクトを取得(拡張特徴ID51)(追加定義) #-------------------------------------------------------------------------- def multi_invoke(item) return 1 unless item.is_a?(RPG::Skill) add_features_object(51)[item.stype_id] ? add_features_object(51)[item.stype_id] : 1 end #-------------------------------------------------------------------------- # ★ オブジェクトを取得(拡張特徴ID55)(追加定義) #-------------------------------------------------------------------------- def special_invoke(id) add_features_object(55).select{|block| block[0] == id} end #消費率------------------------------------------------------------------- #-------------------------------------------------------------------------- # ★ タイプ消費率取得(拡張特徴ID58)(追加定義) #-------------------------------------------------------------------------- def typer(id, type) add_features_object(59)[id][type] ? add_features_object(59)[id][type] : 1 end #-------------------------------------------------------------------------- # ★ タイプ消費加算取得(拡張特徴ID91)(追加定義) #-------------------------------------------------------------------------- def type_add(id, type) add_features_object(91)[id][type] ? add_features_object(91)[id][type] : 0 end #-------------------------------------------------------------------------- # ★ 属性消費率取得(拡張特徴ID92)(追加定義) #-------------------------------------------------------------------------- def cost_e_rate(type, e_id) add_features_object(92)[type][e_id] ? add_features_object(92)[type][e_id] : 1 end #-------------------------------------------------------------------------- # ★ 属性消費加算取得(拡張特徴ID93)(追加定義) #-------------------------------------------------------------------------- def cost_e_add(type, e_id) add_features_object(93)[type][e_id] ? add_features_object(93)[type][e_id] : 0 end #-------------------------------------------------------------------------- # ★ 攻撃属性(拡張特徴ID72)(追加定義) #-------------------------------------------------------------------------- def add_element(item) return [] unless item.is_a?(RPG::Skill) return add_features_object(72).select{|block| block[0] == item.stype_id}.collect{|block| block[1]} end #-------------------------------------------------------------------------- # ★ 身代わりするHP境界値(％)を取得(拡張特徴ID75)(追加定義) #-------------------------------------------------------------------------- def substitute_rate(item) return -1 if item.ignore_substitute > rand(100) return add_features_object(75)[1] if item.certain? return [add_features_object(75)[0], add_features_object(75)[1]].max end #-------------------------------------------------------------------------- # ★ 変数能力値変化(拡張特徴ID82)(追加定義) #-------------------------------------------------------------------------- def variables_revise(id) return 0 unless add_features_object(82)[id] return add_features_object(82)[id].inject(0) {|r, value| r += $game_variables[value]} end #スキル強化、耐性---------------------------------------------------------- #-------------------------------------------------------------------------- # ★ スキルタイプ強化の修正値を取得(拡張特徴ID86)(追加定義) #-------------------------------------------------------------------------- def force_element_rate(id) return nil unless add_features_object(86)[id] return nil if add_features_object(86)[id] == [] add_features_object(86)[id].each{|block| next unless block next if block == [] return block.inject(0.0){|r,i| r+=i }/block.size } return nil end #-------------------------------------------------------------------------- # ★ スキル強化(拡張特徴ID88)(追加定義) #-------------------------------------------------------------------------- def skill_gain_rate(id) result = 0.0 add_features_object(88).each{|block| next unless block[0] == id result += (block[1].to_f / 100)} return result end #-------------------------------------------------------------------------- # ★ スキル耐性(拡張特徴ID89)(追加定義) #-------------------------------------------------------------------------- def skill_drain_rate(id) result = 0.0 add_features_object(89).each{|block| next unless block[0] == id result += (block[1].to_f / 100)} return result end #反撃スキル--------------------------------------------------------------- #-------------------------------------------------------------------------- # ★ 反撃のスキルIDを取得(拡張特徴ID34用)(追加定義) #-------------------------------------------------------------------------- def counter_attack_skill_id(item, elements) list = counter_skill_id_list[item.hit_type] + counter_skill_id_list[3] list_2 = list.select{|block| block[0] == 0 or elements.include?(block[0])}.collect{|block| [block[1], block[2]]} result = list_2.sample return result ? result : [1,0] end #-------------------------------------------------------------------------- # ★ 最終反撃のスキルIDを取得(拡張特徴ID41用)(追加定義) #-------------------------------------------------------------------------- def final_counter(item) return (final_skill_id_list[item.hit_type] + final_skill_id_list[3]).sample end #ダメージ反射-------------------------------------------------------------- #-------------------------------------------------------------------------- # ★ ダメージ反射の確率を取得(拡張特徴ID99用)(追加定義) #-------------------------------------------------------------------------- def reflection_rate(item, elements) result = 0 #命中タイプに応じたレートを読み込み list1 = reflection_dmg_obj[item.hit_type] list2 = reflection_dmg_obj[3] #全属性対応の確率を読み込み result += list1[0] if list1[0] result += list2[0] if list2[0] #属性に対応した確率の読み込み elements.each{|id| next if id == 0 result += list1[id] if list1[id] result += list2[id] if list2[id] } return result end #使用効果無効化------------------------------------------------------------ #-------------------------------------------------------------------------- # ★ 使用効果無効化判定プロセス(拡張特徴ID95用)(追加定義) #-------------------------------------------------------------------------- def effect_invalidate_process(user, item) #貫通能力適用時は処理を終了 return if item.pierce_ability.include?(95) return if user.pierce_obj.include?(95) #データを取得 data = add_features_object(95) #スキル、アイテムで判定を分割 list = data[0] + data[2] if item.is_a?(RPG::Skill) list = data[1] + data[2] if item.is_a?(RPG::Item) list.each{|block| #命中対応対象指定の場合違えば判定を除外 next if block[0] != 3 && block[0] != item.hit_type next if rand(100) >= block[1] @result.effect_invalidate = true if item.damage.none? @result.add_feature_deffence.push([95, block[2], [self.name], 0]) end break } end #-------------------------------------------------------------------------- # ◎ 属性有効度の取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_element_rate :element_rate unless $! def element_rate(element_id) return force_element_rate(element_id) if force_element_rate(element_id) return k_integrate_before_element_rate(element_id) end #-------------------------------------------------------------------------- # ◎ スキル／アイテムの使用(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_use_item :use_item unless $! def use_item(item) k_integrate_before_use_item(item) if actor? #アイテム獲得(スキル特徴ID24) item.gain_items.each{|block| next if rand(100) >= block[2] cond = $game_party.in_battle ? 1 : 2 next if block[4] != 0 && block[4] != cond $game_party.gain_item(KURE.item_obj(block[0], block[1]),block[3]) } end #使用者ID代入(スキル特徴ID49) $game_variables[item.user_id_value] = self.id if item.user_id_value #消費パラメータ item.pram_cost.each{|block| add_param_cost(block[0], -1 * block[1])} end #-------------------------------------------------------------------------- # □ スキル／アイテムの効果適用(再定義) #------------------------------------------------------------------------- def item_apply(user, item) @result.clear @result.used = item_test(user, item) item_success_cheak_process(user, item) #攻撃命中判定 invalidate_cheak_process(user, item) #無効化能力適用プロセス if @result.hit? && !@result.invalidate? effect_invalidate_process(user, item) #使用効果無効化判定プロセス item_adv_effect_apply_before(user, item) #拡張使用効果(発動前) #ダメージがある場合はダメージ処理 unless item.damage.none? @result.critical = (rand < item_cri(user, item)) make_damage_value(user, item) execute_damage(user) end #エフェクトが無効化されていなければ適用 unless @result.effect_invalidate item.effects.each {|effect| item_effect_apply(user, item, effect) } end item_adv_effect_apply_after(user, item) #拡張使用効果(発動後) item_user_effect(user, item) counter_state_process(user, item) #ステート反撃適用プロセス end end #-------------------------------------------------------------------------- # ★ スキル／アイテムの拡張効果の適用(発動前)(追加定義) #------------------------------------------------------------------------- def item_adv_effect_apply_before(user, item) return if @result.effect_invalidate state_copy_process(user, item) #ステート転写 state_claer_effect_process(user, item) #ステート初期化 end #-------------------------------------------------------------------------- # ★ ステート初期化プロセス(スキル能力ID13) #-------------------------------------------------------------------------- def state_claer_effect_process(user, item) return unless item.clear_state_rate > rand(100) cheak_list = item.not_clear_type states.each {|state| remove_state(state.id) if !cheak_list.include?(state.state_type)} end #-------------------------------------------------------------------------- # ★ ステート転写プロセス(スキル能力ID53) #-------------------------------------------------------------------------- def state_copy_process(user, item) data = item.copy_state return unless data if data[0] && data[0] != [] state_list = user.states.collect{|state| state.id} state_list.each{|id| add_state(id) if data[0].include?(id)} end if data[1] && data[1] != [] state_list = states.collect{|state| state.id} state_list.each{|id| user.add_state(id) if data[1].include?(id)} end end #-------------------------------------------------------------------------- # ★ スキル／アイテムの拡張効果の適用(発動後)(追加定義) #------------------------------------------------------------------------- def item_adv_effect_apply_after(user, item) #使用効果無効化時でなければ反映 unless @result.effect_invalidate @ad_counter[0] += item.deffence_wall_add #ID15(防御壁追加) @ad_counter[1] += item.auto_revive_add #ID16(自動復活追加) @ad_counter[2] += item.delay_state_add #ID17(遅延ステート追加) item.grow_pram.each{|block| add_param_cost(block[0], block[1])} #ID33(成長) end #使用効果無効化に関係なく反映 @ad_counter[3] += trap_maker(user, item) #ID18(トラップ設置) @ad_counter[4] += substitute_maker(user, item) #ID34(身代わり対象) steal_process(user, item) if self.enemy? && item.steal_id #ID14(スティール) reduce_durable_process(user, item, 0) if self.actor? reduce_durable_process(user, item, 1) if user.actor? element_react_state_process(user, item) #属性反応ステートプロセス end #-------------------------------------------------------------------------- # □ ダメージ計算(再定義) #-------------------------------------------------------------------------- def make_damage_value(user, item) value = item.damage.eval(user, self, $game_variables) value *= item_element_rate(user, item) value *= item_weapon_rate(user, item) value *= item_hit_type_rate(user, item) value *= item_scope_type_rate(user, item) value *= item_skill_type_rate(user, item) value *= item_skill_id_rate(user, item) value *= item_recover_rate(user, item) if item.damage.recover? value *= item_feature_rate(user, item) value = apply_critical_rate(value, user) if @result.critical value = apply_add_feature_rate(value, user, item) value = apply_variance(user, value, item.damage.variance) value = apply_guard(value) value = apply_add_feature_deffence(value, user, item) value = apply_dispersion(value, item) #1.32テスト実装 @result.make_damage(value.to_i, item) end #-------------------------------------------------------------------------- # ★ 分散度の適用(再定義) #-------------------------------------------------------------------------- def apply_variance(user, damage, variance) #分散度を適用して取得(0〜100の範囲内) new_variance = [[variance + user.var_revise, 0].max ,100].min amp = [damage.abs * new_variance / 100, 0].max.to_i var = rand(amp + 1) + rand(amp + 1) - amp damage >= 0 ? damage + var : damage - var end #-------------------------------------------------------------------------- # ★ 分散型スキルのダメージ適用(追加定義) #-------------------------------------------------------------------------- def apply_dispersion(value, item) #威力分散では無い場合は値をそのまま返す return value unless item.dispersion num = @target_num ? @target_num : 1 return value / num end #-------------------------------------------------------------------------- # ★ スキル／アイテムの拡張特徴の修正値を取得(追加定義) #-------------------------------------------------------------------------- def apply_add_feature_rate(damage, user, item) #ID22(逆境補正) damage *= (1 + (user.adversity_cut_rate[0] * user.friends_unit.dead_num)) damage *= (1 - (adversity_cut_rate[1] * friends_unit.dead_num)) #ID36、37(反撃補正) if user.result.counter result = 1.0 * user.counter_attack_gain_rate result -= counter_attack_drain_rate damage *= result end #ID47、48(反射補正) if user.magic_reflection result = 1.0 * user.reflection_gain_rate result -= reflection_drain_rate damage *= result end return damage end #-------------------------------------------------------------------------- # ★ スキル／アイテムの拡張特徴の防御の能力を適用(追加定義) #-------------------------------------------------------------------------- def apply_add_feature_deffence(damage, user, item) return damage if !opposite?(user) damage = invalidate_wall_apply(user, item, damage) #ID24(無効化障壁) damage = defence_wall_apply(user, item, damage) #ID26(ダメージ減少) #ID23(ダメージ上限) damage = damage_limit_value if damage > damage_limit_value && damage_limit_value != 0 && !item.pierce_ability.include?(23) damage = damage_convert_apply(user, item, damage) #ID32(ダメージ変換) damage_collect_apply(damage) #ID33(ダメージ回収) damage = auto_stand_apply(user, item, damage) #ID27(踏みとどまり) return damage end #-------------------------------------------------------------------------- # ★ 命中率判定チェック(追加定義) #-------------------------------------------------------------------------- def item_success_cheak_process(user, item) case KURE::Integrate::HIT_CHEAK_MODE when 0 #通常判定(命中成功判定と回避判定を別で行う) @result.missed = (@result.used && rand >= item_hit(user, item)) @result.evaded = (!@result.missed && rand < item_eva(user, item)) when 1 #拡張判定(成功判定と命中回避判定で行う) @result.missed = (@result.used && rand(100) >= item.success_rate) @result.evaded = (!@result.missed && rand > item_ex_hit(user, item)) end end #-------------------------------------------------------------------------- # ◎ 会心率計算(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_item_cri :item_cri unless $! def item_cri(user, item) item.damage.critical ? k_integrate_before_item_cri(user, item) : 0 end #-------------------------------------------------------------------------- # ● スキル／アイテムの会心率計算(再定義) #-------------------------------------------------------------------------- def item_cri(user, item) #判定しないものは0を返す return 0 unless item.damage.critical case KURE::Integrate::HIT_CHEAK_MODE when 0 #通常判定(会心率と会心回避率を乗算で計算する) return (user.cri * (1 - cev)) + item.cri_gain_rate when 1 #拡張判定(会心率より会心回避率を減算で計算する) return (user.cri - cev ) + item.cri_gain_rate end end #-------------------------------------------------------------------------- # ◎ 命中率計算(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_item_hit :item_hit unless $! def item_hit(user, item) new_rate = k_integrate_before_item_hit(user, item) new_rate *= user.mhit if item.magical? return new_rate end #-------------------------------------------------------------------------- # ★ 拡張命中率の計算(追加定義) #-------------------------------------------------------------------------- def item_ex_hit(user, item) return [user.hit - eva ,KURE::Integrate::MIN_HIT_RATE].max if item.physical? return [user.mhit - mev,KURE::Integrate::MIN_HIT_RATE].max if item.magical? return 1 end #-------------------------------------------------------------------------- # ★ 無効化能力の発動チェック(追加定義) #-------------------------------------------------------------------------- def invalidate_cheak_process(user, item) return if !opposite?(user) #ID62(防御壁展開) unless user.pierce_obj.include?(62) #貫通技能判定 unless item.pierce_ability.include?(62) #貫通能力判定 @ad_counter[0].each_with_index{|block, index| next if block[0] != 3 && block[0] != item.hit_type next if rand(100) >= block[2] next if block[1] < 1 @ad_counter[0][index][1] -= 1 @ad_counter[0][index][1] -= item.break_wall if block[1] >= 0 @result.add_feature_invalidate.push([43, 0, [user.name, item.break_wall + 1], 2]) if item.break_wall > 0 @result.add_feature_invalidate.push([62, block[4], [name], 0]) if block[1] == 0 erase_state(block[3]) if block[3] != 0 @ad_counter[0][index] = nil end @ad_counter[0].compact! return else @result.add_feature_deffence.push([43, 1, [user.name], 2]) erase_state(block[3]) if block[3] != 0 @ad_counter[0][index] = nil @ad_counter[0].compact! return end } end end #ID25(命中タイプ無効化) unless user.pierce_obj.include?(25) unless item.pierce_ability.include?(25) hit_type_invalidate.each {|block| #アイテム対象のデータはスキルで反映しない next if block[0] == 1 && item.is_a?(RPG::Skill) #スキル対象のデータはアイテムでは反映しない next if block[0] == 0 && item.is_a?(RPG::Item) next if block[1] != 3 && block[1] != item.hit_type next if rand(100) >= block[2] @result.add_feature_invalidate.push([25, block[3], [name], 0]) return } end end end #-------------------------------------------------------------------------- # □ スキル／アイテムの属性修正値を取得(再定義) #-------------------------------------------------------------------------- def item_element_rate(user, item) return normal_attacck_rate(user, item) if item.damage.element_id < 0 return element_attacck_rate(user, item) end #-------------------------------------------------------------------------- # ★ 属性攻撃のスキル／アイテムの属性修正値を取得(追加定義) #-------------------------------------------------------------------------- def element_attacck_rate(user, item) element = basic_element_list(user, item) return element.empty? ? 1.0 : elements_total_rate(user, element) end #-------------------------------------------------------------------------- # ★ 通常攻撃属性スキル／アイテムの属性修正値を取得(追加定義) #-------------------------------------------------------------------------- def normal_attacck_rate(user, item) element = basic_element_list(user, item) result = element.empty? ? 1.0 : elements_total_rate(user, element) result *= user.normal_attack_gain_rate result *= user.weapon_rate(user, item) result -= normal_attack_drain_rate return result end #-------------------------------------------------------------------------- # ★ 属性攻撃のスキル／アイテムの属性修正値を取得(追加定義) #-------------------------------------------------------------------------- def element_skill_rate(user, element_id) result = 1.0 result *= user.element_gain_rate(element_id) result *= element_rate(element_id) result += user.element_add_rate(element_id) result -= element_drain_rate(element_id) return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムの属性リストを取得(追加定義) #-------------------------------------------------------------------------- def basic_element_list(user, item) element = item.damage.element_id < 0 ? user.atk_elements : [item.damage.element_id] element += user.add_element(item) element += item.reflect_elements return element.uniq end #-------------------------------------------------------------------------- # ★ 属性の修正値計算 #-------------------------------------------------------------------------- def elements_total_rate(user, elements) case KURE::Integrate::ELEMENT_RATE_MODE #モード0(相性値を配列で出力し、最大値を取る) when 0 ; elements.inject([]) {|r, i| r.push(element_skill_rate(user, i)) }.max #モード1(相性値を正と負で乗算し、差分を求める) when 1 sum_p = 1.0 ; sum_m = 1.0 elements.each{|id| #属性レート値を取得 value = element_skill_rate(user, id) #正の値の場合は単純に乗算する if value >= 0 sum_p *= value #負の値の場合 else sum_m *= (1 + value.abs) end } return sum_p + (1 - sum_m) #モード2(相性値を正と負で分割し、加算する) when 2 sum = 1.0 elements.each{|id| #属性レート値を取得 value = element_skill_rate(user, id) #正の値の場合は基準点100の差分を加算する if value >= 0 sum += (value - 1) #負の値の場合は単純な加算を行う else sum += value end } return sum #モード3(相性値正のみを加算し、負の場合は最大値を採用する) when 3 sum_p = 0 ; sum_m = [] elements.each{|id| #属性レート値を取得 value = element_skill_rate(user, id) #値が1以上の場合は基準からの差分を加算する。 if value > 1 sum_p += (value - 1) #値が1以下の場合は値を記録する else sum_m.push(value) end } #正の加算値が存在する場合は1を加えて値を返す return (1 + sum_p) if sum_p != 0 #正の加算値が存在しない場合は値の最大値を返す return sum_m.max end end #-------------------------------------------------------------------------- # ★ 武器タイプ強化の修正値を取得(追加定義) #-------------------------------------------------------------------------- def weapon_rate(user, item) return 1.0 unless user.actor? result = 1.0 equip_type = user.weapons.collect{|item| item.wtype_id} equip_type.each{|id| result *= user.weapon_gain_rate(id)} return result end #-------------------------------------------------------------------------- # ★ スキルの武器強化の修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_weapon_rate(user, item) return 1.0 unless user.actor? result = 1.0 equip_type = user.weapons.collect{|item| item.wtype_id} equip_type.each{|id| result *= item.get_weapon_revise(id)} return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムの命中タイプ修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_hit_type_rate(user, item) result = 1.0 result *= user.hit_type_gain_rate(item.hit_type) case item.hit_type when 1 ; result *= pdr when 2 ; result *= mdr end result += user.hit_type_add_rate(item.hit_type) result -= hit_type_drain_rate(item.hit_type) if !item.damage.recover? return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムの効果範囲修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_scope_type_rate(user, item) result = 1.0 result *= user.scope_type_gain_rate(item.scope) result += user.scope_type_add_rate(item.scope) result -= scope_type_drain_rate(item.scope) if !item.damage.recover? return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムのスキルタイプ修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_skill_type_rate(user, item) return 1.0 unless item.is_a?(RPG::Skill) result = 1.0 ; skill_type_id = [item.stype_id] + item.add_skill_type skill_type_id.each{|id| result *= user.skill_type_gain_rate(id) result -= skill_type_drain_rate(id)} if !item.damage.recover? return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムのスキルID修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_skill_id_rate(user, item) return 1.0 unless item.is_a?(RPG::Skill) result = 1.0 result += user.skill_gain_rate(item.id) result -= skill_drain_rate(item.id) if !item.damage.recover? return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムの回復効果修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_recover_rate(user, item) result = 1.0 ; type = 0 case item.damage.type when 3 ; type = 0 when 4 ; type = 1 end result *= user.recover_gain_rate(type) result *= rec if user.ignore_rec_rate == 0 result += user.recover_add_rate(type) result -= recover_drain_rate(type) return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムの拡張能力補正値を取得(追加定義) #-------------------------------------------------------------------------- def item_feature_rate(user, item) result = 1.0 @states.each{|id| result *= item.get_state_revise(id)} return result end #-------------------------------------------------------------------------- # □ 使用効果［HP 回復］(再定義) #-------------------------------------------------------------------------- def item_effect_recover_hp(user, item, effect) value = (mhp * effect.value1 + effect.value2) * rec value *= user.pha if item.is_a?(RPG::Item) value *= item_recover_rate_effect(user, item, 0) if item.is_a?(RPG::Skill) value = value.to_i @result.hp_damage -= value @result.success = true self.hp += value end #-------------------------------------------------------------------------- # □ 使用効果［MP 回復］(再定義) #-------------------------------------------------------------------------- def item_effect_recover_mp(user, item, effect) value = (mmp * effect.value1 + effect.value2) * rec value *= user.pha if item.is_a?(RPG::Item) value *= item_recover_rate_effect(user, item, 1) if item.is_a?(RPG::Skill) value = value.to_i @result.mp_damage -= value @result.success = true if value != 0 self.mp += value end #-------------------------------------------------------------------------- # □ 使用効果［TP 増加］(再定義) #-------------------------------------------------------------------------- def item_effect_gain_tp(user, item, effect) value = effect.value1.to_i value *= item_recover_rate_effect(user, item, 2) if item.is_a?(RPG::Skill) value = value.to_i @result.tp_damage -= value @result.success = true if value != 0 self.tp += value end #-------------------------------------------------------------------------- # ★ スキル／アイテムの回復効果修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_recover_rate_effect(user, item, type) result = 1.0 result *= user.recover_gain_rate(type) result *= rec result += user.recover_add_rate(type) result -= recover_drain_rate(type) return result end #-------------------------------------------------------------------------- # ★ スキル／アイテムのステート修正値を取得(追加定義) #-------------------------------------------------------------------------- def item_state_rate(base, user, state_id, item) result = base #ステート有効度、無視のスキルや使用者が特徴持ちの場合は処理しない if !item.ignore_state_rate && user.ignore_state_rate_ft == 0 result *= state_rate(state_id) result *= param_effect_rate(user, state_id, item) end result *= user.state_gain_rate(state_id) result += user.state_add_rate(state_id) #ステート有効度、無視のスキルや使用者が特徴持ちの場合は処理しない if !item.ignore_state_rate && user.ignore_state_rate_ft == 0 result -= state_drain_rate(state_id) end return result end #-------------------------------------------------------------------------- # ★ パラメータによる有効度変化率の取得(追加定義) #-------------------------------------------------------------------------- def param_effect_rate(user, state_id, item) list = item.get_state_param(state_id) return 1.0 unless list user_j_param = user.param(list[0]) self_j_param = param(list[1]) return [1.0 + (user_j_param - self_j_param) * 0.001, 0.0].max end #-------------------------------------------------------------------------- # □ 使用効果［ステート付加］：通常攻撃(再定義) #-------------------------------------------------------------------------- def item_effect_add_state_attack(user, item, effect) user.atk_states.each do |state_id| chance = effect.value1 chance *= user.atk_states_rate(state_id) chance = item_state_rate(chance, user, state_id, item) state_add_process(chance, state_id) end end #-------------------------------------------------------------------------- # □ 使用効果［ステート付加］：通常(再定義) #-------------------------------------------------------------------------- def item_effect_add_state_normal(user, item, effect) chance = effect.value1 chance = item_state_rate(chance, user, effect.data_id, item) if opposite?(user) state_add_process(chance, effect.data_id) end #-------------------------------------------------------------------------- # ★ 使用効果［ステート付加］(実行処理)(追加定義) #-------------------------------------------------------------------------- def state_add_process(chance, state_id) return unless rand < chance if state_id == death_state_id reverse_deth.each{|block| next if rand(100) >= block[1] value = (mhp * (block[0].to_f / 100)).to_i self.hp += value @result.add_feature_deffence.push([60, block[2], [name, value], 0]) @result.success = true return } end add_state(state_id) @result.success = true end #-------------------------------------------------------------------------- # ★ スキル／アイテムのクリティカル修正値を取得(追加定義) #-------------------------------------------------------------------------- def apply_critical_rate(damage, user) result = 1.0 result *= KURE::Integrate::C_BASIC_CRITICAL result *= user.critiacal_gain_rate result *= critiacal_rate result += user.critiacal_add_rate result -= critiacal_drain_rate return damage * result end #-------------------------------------------------------------------------- # ★ ダメージ無効化を適用(ID24)(追加定義) #-------------------------------------------------------------------------- def invalidate_wall_apply(user, item, damage) return damage if damage <= 0 return damage if item.pierce_ability.include?(24) return damage if user.pierce_obj.include?(24) invalidate_wall.each {|block| next if damage > block[0] @result.add_feature_invalidate.push([24, block[1], [name], 0]) return 0 } return damage end #-------------------------------------------------------------------------- # ★ ダメージ減少を適用(ID26)(追加定義) #-------------------------------------------------------------------------- def defence_wall_apply(user, item, damage) return damage if damage <= 0 return damage if item.pierce_ability.include?(26) return damage if user.pierce_obj.include?(26) defence_wall.each {|block| next if rand(100) >= block[2] damage -= block[0] damage *= (1.0 - (block[1].to_f / 100) ) @result.add_feature_deffence.push([26, block[3], [name], 0]) return 0 if damage <= 0 } return damage end #-------------------------------------------------------------------------- # ★ 踏みとどまりを適用(ID27)(追加定義) #-------------------------------------------------------------------------- def auto_stand_apply(user, item, damage) return damage if damage <= 0 return damage if item.pierce_ability.include?(27) return damage if user.pierce_obj.include?(27) return damage if hp - damage > 0 auto_stand.each {|block| next if rand(100) >= block[1] next if block[0] == 0 next if block[0].to_f / 100 > hp_rate @result.add_feature_after.push([27, block[2], [name], 0]) return hp - 1 } return damage end #-------------------------------------------------------------------------- # ★ ダメージ変換を適用(ID32)(追加定義) #-------------------------------------------------------------------------- def damage_convert_apply(user, item, damage) return damage if damage <= 0 return damage if item.pierce_ability.include?(32) return damage if user.pierce_obj.include?(32) damage_convert.each {|block| next if rand(100) >= block[2] reduce = [1, (damage * (block[1].to_f / 100)).to_i].max case block[0] when 0 next if self.mp == 0 damage = [0 , damage - (self.mp / (block[1].to_f / 100))].max self.mp = [0, self.mp - reduce].max when 1 next if self.tp == 0 damage = [0 , damage - (self.tp / (block[1].to_f / 100))].max self.tp = [0, self.tp - reduce].max when 2 next if $game_party.gold == 0 damage = [0 , damage - ($game_party.gold / (block[1].to_f / 100))].max $game_party.lose_gold(reduce) end @result.add_feature_deffence.push([32, block[3], [name, reduce.to_s], 0]) return damage if damage <= 0 } return damage end #-------------------------------------------------------------------------- # ★ ダメージ回収を適用(ID33)(追加定義) #-------------------------------------------------------------------------- def damage_collect_apply(damage) return damage if damage <= 0 damage_collect.each {|block| next if rand(100) >= block[2] gain = (damage * (block[1].to_f / 100)).to_i case block[0] when 0 ; self.mp += gain when 1 ; self.tp += gain when 2 ; $game_party.gain_gold(gain) end @result.add_feature_after.push([33, block[3], [name, gain], 0]) } return damage end #-------------------------------------------------------------------------- # ★ スキル／アイテムの反撃率計算(拡張特徴30,31,38)(追加定義) #-------------------------------------------------------------------------- def item_cnt_ex(user, item, mode) return 0 if item.impossible_counter > rand(100) #反撃不可スキル判定 return 0 unless opposite?(user) # 味方には反撃しない return 0 unless movable? #行動不可時は反撃でない #スキルの属性を配列で取得 e_list = basic_element_list(user, item) case mode #通常反撃(行動前反撃) when 0 ; normal_cnt_rate(item, e_list) #通常反撃 when 1 ; adv_cnt_rate(item, e_list) #拡張反撃(行動後反撃) when 2 ; sub_cnt_rate(item, e_list) #身代わり反撃 end end #-------------------------------------------------------------------------- # ★ スキル／アイテムの反射計算(拡張特徴46,46)(追加定義) #-------------------------------------------------------------------------- def item_mrf_ex(user, item, mode) return 0 if item.impossible_refrect > rand(100) #反射不可スキル判定 return 0 if KURE::Integrate::HEAL_REFRECT == 0 && item.damage.recover? return 0 if user == self #自分には反射しない case item.hit_type when 0 ; return cer_rf_rate when 1 ; return phy_rf_rate when 2 ; return mrf end return 0 end #-------------------------------------------------------------------------- # ★ スキル／アイテムの回避反撃率計算(拡張特徴ID39)(追加定義) #-------------------------------------------------------------------------- def eva_counter_rate(user, item, mode) return 0 if item.impossible_counter > rand(100) #反撃不可スキル判定 return 0 unless opposite?(user) # 味方には反撃しない return 0 unless movable? #行動不可時は反撃でない #スキルの属性を配列で取得 e_list = basic_element_list(user, item) return eva_cnt_rate(item, e_list) end #-------------------------------------------------------------------------- # ★ ステート反撃プロセス(拡張特徴ID40)(追加定義) #-------------------------------------------------------------------------- def counter_state_process(user, item) return if counter_states == [] #カウンターステートが無ければ処理しない return if item.impossible_counter > rand(100) #反撃不可スキル判定 return unless opposite?(user) # 味方には反撃しない element = basic_element_list(user, item) #攻撃者の属性を取得 counter_states.each{|block| next if block[0] != item.hit_type && block[0] != 3 next if block[1] != 0 && !element.include?(block[1]) next if rand > user.item_state_rate(block[3].to_f / 100, self, block[2], item) @result.add_feature_after.push([40, block[4], [name], 0]) next if counter_state_break_process(user, item) user.add_state(block[2]) @result.add_feature_after.push([user, nil, nil, 1]) } end #-------------------------------------------------------------------------- # ★ ステート反撃無効化プロセス(拡張特徴ID52)(追加定義) #-------------------------------------------------------------------------- def counter_state_break_process(user, item) user.counter_state_break_obj.each{|block| next if rand(100) >= block[0] @result.add_feature_after.push([52, block[1], [user.name], 0]) return true } return false end #-------------------------------------------------------------------------- # ★ 自爆耐性判定(拡張特徴ID68)(追加定義) #-------------------------------------------------------------------------- def pay_life(item) add_state(death_state_id) perform_collapse_effect end #-------------------------------------------------------------------------- # ★ 属性反応ステートプロセス(拡張能力ID84) #-------------------------------------------------------------------------- def element_react_state_process(user, item) element = basic_element_list(user, item) element_react_state.each{|block| next unless element.include?(block[0]) next if item.hit_type != block[1] && block[1] != 3 add_state(block[2])} end #-------------------------------------------------------------------------- # ★ スティール判定(スキル能力ID14)(追加定義) #-------------------------------------------------------------------------- def steal_process(user, item) if @result.stealed @result.add_feature_after.push([14, 2, [self.name], 2]) return end list = self.steal_list(item.steal_id) if list == [] @result.stealed = true @result.add_feature_after.push([14, 2, [self.name], 2]) return end list.each{|block| next if rand(1000) > block[3] * user.steal_rate sound = KURE::Integrate::STEAL_ITEM_SE Audio.se_play('Audio/SE/' + sound[0], sound[1], sound[2]) if block[1] == 3 value = rand(block[2]) + 1 view_name = value.to_s + Vocab.currency_unit icon = '\I[' + KURE::Integrate::STEAL_GOLD_ICON.to_s + ']' $game_party.gain_gold(value) else item_data = KURE.item_obj(block[1], block[2]) icon = '\I[' + item_data.icon_index.to_s + ']' view_name = item_data.name $game_party.gain_item(item_data, 1) end font = '\C['+ KURE::Integrate::STEAL_ITEM_FONT_COLOR.to_s + ']' @result.add_feature_after.push([14, 0, [self.name, icon + font + view_name + '\C[0]'], 2]) @result.stealed = true return } @result.add_feature_after.push([14, 1, [self.name], 2]) end #-------------------------------------------------------------------------- # ★ トラップ設置(スキル能力ID18)(追加定義) #-------------------------------------------------------------------------- def trap_maker(user, item) result = item.trap_setting result.each{|block| block.push(user)} @result.success = true if result != [] return result end #-------------------------------------------------------------------------- # ★ 耐久値操作(スキル能力ID19)(追加定義) #-------------------------------------------------------------------------- def reduce_durable_process(user, item, mode) return unless $kure_integrate_script[:SortOut] case mode when 0 ; list = item.durable_damage ; battler = self when 1 ; list = item.durable_cost ; battler = user end list.each{|block| next if rand(100) >= block[2] equip_list = battler.equips.select{|obj| obj && obj.etype_id == block[0]} equip_list.each{|equip| next if equip.broken? #アイテム名取得 before_name = equip.name #耐久値操作 equip.reduce_durable_value = (block[1] * battler.durable_rate).to_i next unless equip.broken? @result.add_feature_after.push([20, block[3], [battler.name, before_name], 2]) } } battler.equips.each_with_index{|obj ,index| next unless obj next unless obj.broken? if KURE::SortOut::BROKEN_SETTING == 1 master_container = $game_party.item_master_container(obj.class) delete_item_id = obj.identify_id battler.equips[index] = nil master_container[delete_item_id] = nil end battler.change_equip(index, nil) if KURE::SortOut::BROKEN_CAN_EQUIP == 1 } battler.refresh end #-------------------------------------------------------------------------- # ★ 身代わり対象(スキル能力ID34)(追加定義) #-------------------------------------------------------------------------- def substitute_maker(user, item) result = item.substitute_add result.each{|block| block.push(user)} @result.success = true if result != [] return result end #-------------------------------------------------------------------------- # ★ 戦闘行動を消去(スキル能力ID41)(追加定義) #-------------------------------------------------------------------------- def clear_select_action(index) return unless @actions[index] @actions[index] = nil end #-------------------------------------------------------------------------- # ★ 反動プロセス(スキル能力ID57)(追加定義) #-------------------------------------------------------------------------- def self_react_process(item, damage) return unless damage > 0 value1 = item.self_react[0] + change_self_react[0] value2 = item.self_react[1] + change_self_react[1] value3 = item.self_react[2] + change_self_react[2] #ダメージの計算 apply_damage = value1 + (damage * (value2.to_f / 100)).to_i apply_damage = [[apply_damage, self.hp - 1].min, 0].max if value3 != 0 perform_damage_effect if enemy? perform_damage_effect if actor? self.hp -= apply_damage perform_collapse_effect if dead? end #-------------------------------------------------------------------------- # ★ ダメージ反射プロセス(拡張特徴ID99)(追加定義) #-------------------------------------------------------------------------- def reflection_dmg_process(item, damage) return unless damage > 0 #ダメージの計算 perform_damage_effect if enemy? perform_damage_effect if actor? self.hp -= damage perform_collapse_effect if dead? end #-------------------------------------------------------------------------- # ★ ダメージ反射修正値を取得(追加定義) #-------------------------------------------------------------------------- def apply_reflection_dmg_rate(damage, user) result = 1.0 result *= user.reflection_dmg_rate result *= reflection_dmg_gain_rate result += reflection_dmg_add_rate result -= user.reflection_dmg_drain_rate return (damage * result).to_i end end #============================================================================== # ■ Scene_Battle #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # □ アニメーション表示が終わるまでウェイト(再定義) #-------------------------------------------------------------------------- def wait_for_animation update_for_wait while @spriteset.animation? end #-------------------------------------------------------------------------- # □ 戦闘開始(再定義) #-------------------------------------------------------------------------- def battle_start BattleManager.battle_start all_battle_members.each{|battler| battler.auto_state_adder} #戦闘開始時発動拡張処理 battle_start_add_event #戦闘開始時スキル発動 special_invoke_process(0) process_event start_party_command_selection end #-------------------------------------------------------------------------- # ◎ ターン開始(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_turn_start :turn_start unless $! def turn_start k_integrate_before_turn_start special_invoke_process(1) end #-------------------------------------------------------------------------- # ◎ ターン終了(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_turn_end :turn_end unless $! def turn_end special_invoke_process(2) #ターン終了時発動拡張処理 turn_end_add_event all_battle_members.each{|battler| if battler.alive? delay_state_process(battler) invoke_chase_attack(battler) end auto_revive_process(battler, 1) unless battler.alive? } k_integrate_before_turn_end end #-------------------------------------------------------------------------- # □ 戦闘行動の実行(再定義) #-------------------------------------------------------------------------- def execute_action $game_party.set_dead_num $game_troop.set_dead_num @subject.sprite_effect_type = :whiten #アイテムの取得 item = @subject.current_action.item #連続発動 @subject.multi_invoke(item).times{ next if !@subject.alive? or !@subject.movable? use_item @log_window.wait_and_clear } end #-------------------------------------------------------------------------- # ● 発動前コモンイベント(追加定義) #-------------------------------------------------------------------------- def pre_common_process(item) return unless item.pre_common $game_temp.reserve_common_event(item.pre_common) $game_troop.setup_battle_event process_event update_for_wait @status_window.open end #-------------------------------------------------------------------------- # □ スキル／アイテムの使用(再定義) #-------------------------------------------------------------------------- def use_item return if $game_troop.all_dead? return if !@subject.alive? or !@subject.movable? return unless @subject.current_action item = @subject.current_action.item return unless @subject.skill_conditions_met?(item) if item.is_a?(RPG::Skill) return unless @subject.item_conditions_met?(item) if item.is_a?(RPG::Item) #連携発動判定 team = team_attack_process(item) if team team[0].use_item(team[1]) team_skill = team[2] @log_window.message_block_view(@subject, [[41, team[3], [@subject.name, team[0].name, team[2].name], 2]]) else team_skill = item @log_window.display_use_item(@subject, team_skill) end #発動前コモン pre_common_process(team_skill) @subject.use_item(team_skill) refresh_status #スキル変化と行動変化 new_item = change_skill_process(@subject, team_skill) new_item = change_action_process(@subject, new_item) #スキルを再セット @subject.current_action.item_set(new_item) #連鎖発動設定 invoke_list = [new_item] while invoke_list != [] do chain_action = invoke_list[0] break unless chain_action #連続発動 chain_action.multi_skill_effect.each{|id| next if !@subject.alive? or !@subject.movable? next if $game_troop.all_dead? invoke_obj = $data_skills[id] if chain_action.is_a?(RPG::Skill) invoke_obj = $data_items[id] if chain_action.is_a?(RPG::Item) @subject.current_action.item_set(invoke_obj) targets = @subject.current_action.make_targets.compact @target_num = targets.size #Ver1.32テスト実装 invoke_obj = state_change_process(targets, invoke_obj) show_animation_set(targets, @subject, invoke_obj) targets.each {|target| invoke_obj.repeats.times { invoke_item(target, invoke_obj)}} } invoke_list += chain_action_process(invoke_list[0]) invoke_list.shift @log_window.back_one if invoke_list != [] end after_use_item(@subject, item) refresh_status end #-------------------------------------------------------------------------- # ★ スキル／アイテムの使用(コスト無し)(追加定義) #-------------------------------------------------------------------------- def use_item_no_cost return if $game_troop.all_dead? return if !@subject.alive? or !@subject.movable? return unless @subject.current_action item = @subject.current_action.item #発動前コモン pre_common_process(item) #連鎖発動設定 invoke_list = [item] while invoke_list != [] do chain_action = invoke_list[0] break unless chain_action @log_window.display_use_item(@subject, chain_action) chain_action.effects.each {|effect| @subject.item_global_effect_apply(effect) } refresh_status #連続発動 chain_action.multi_skill_effect.each{|id| next if !@subject.alive? or !@subject.movable? next if $game_troop.all_dead? invoke_obj = $data_skills[id] if item.is_a?(RPG::Skill) invoke_obj = $data_items[id] if item.is_a?(RPG::Item) @subject.current_action.item_set(invoke_obj) targets = @subject.current_action.make_targets.compact @target_num = targets.size #Ver1.32テスト実装 invoke_obj = state_change_process(targets, invoke_obj) show_animation_set(targets, @subject, invoke_obj) targets.each {|target| invoke_obj.repeats.times { invoke_item(target, invoke_obj)}} } invoke_list += chain_action_process(invoke_list[0]) invoke_list.shift @log_window.back_one if invoke_list != [] end after_use_item(@subject, item) refresh_status end #-------------------------------------------------------------------------- # □ スキル／アイテムの発動(再定義) #-------------------------------------------------------------------------- def invoke_item(target, item) #トラップ発動 invoke_trap(@subject, item, target) return if !@subject.alive? or !@subject.movable? #スキル変換 item = convert_object_process(target, item) #対象ID代入(スキル特徴ID49) $game_variables[item.target_id_value] = target.id if item.target_id_value if rand < target.item_cnt_ex(@subject, item, 0) invoke_counter_attack(target, item) elsif rand < target.item_mrf_ex(@subject, item, 0) invoke_magic_reflection(target, @subject, item) else #ターゲット変更プロセス new_target = apply_change_target(@subject, target, item) apply_item_effects_set(@subject, item, [new_target]) #行動反応追撃プロセス invoke_reaction_attack(@subject, item, new_target) #拡張行動反撃プロセス、身代わり反撃プロセス invoke_counter_attack(target, item) if rand < target.item_cnt_ex(@subject, item, 1) invoke_counter_attack(new_target, item) if target != new_target && rand < new_target.item_cnt_ex(@subject, item, 2) #対象ID代入(スキル特徴ID49) $game_variables[item.target_id_value] = new_target.id if item.target_id_value end #回避反撃プロセス if target.result.evaded && rand < target.eva_counter_rate(@subject, item, 0) invoke_counter_attack(target, item) end @subject.last_target_index = target.index end #-------------------------------------------------------------------------- # ★ ターゲット変更に関係する処理(追加定義) #-------------------------------------------------------------------------- def apply_change_target(attacker, target, item) #属性対象のターゲット変更 result = apply_element_target(attacker, target, item) #身代わりの適用 result = apply_substitute_ex(attacker, result, item) return result end #-------------------------------------------------------------------------- # ★ ターゲット変更を適用(追加定義) #-------------------------------------------------------------------------- def apply_element_target(attacker, target, item) return target unless item.target_change_skill #攻撃属性を取得 elements = attacker.basic_element_list(attacker, item) result = [] all_battle_members.each{|battler| battler.target_element.each{|id| if elements.include?(id) result.push(battler) break end } } return target if result == [] return result.sample end #-------------------------------------------------------------------------- # ★ 身代りを適用(汎用)(追加定義) #-------------------------------------------------------------------------- def apply_substitute_ex(attacker, target, item) return target if item.ignore_substitute > rand(100) rate = target.hp_rate * 100 #対象の残りHP(%)を取得 if attacker.opposite?(target) #拡張身代わりの設定 substitute_ex = target.friends_unit.movable_members.select{|battler| rate <= battler.substitute_rate(item) && battler != target} if substitute_ex != [] substitute_unit = substitute_ex.sample @log_window.display_substitute(substitute_unit, target) return substitute_unit end #身代わり対象 substitute_ex2 = target.ad_counter[4].collect{|block| block[4] if rate <= block[1] && (block[0] == 1 || !item.certain?)} substitute_ex2 = substitute_ex2.select{|battler| battler && battler != target} if substitute_ex2 != [] substitute_unit = substitute_ex2.sample @log_window.display_substitute(substitute_unit, target) return substitute_unit end end apply_substitute(target, item) end #-------------------------------------------------------------------------- # ★ ターゲットにエフェクトを適用(汎用)(追加定義) #-------------------------------------------------------------------------- def effect_adopter(user, item, targets, mode = 0) item.multi_skill_effect.each{|id| next if mode == 0 && (!user.alive? or !user.movable?) invoke_obj = $data_skills[id] show_animation_set(targets, user, invoke_obj) apply_item_effects_set(user, invoke_obj, targets) } end #-------------------------------------------------------------------------- # ★ スキル／アイテムの効果を適用(汎用)(追加定義) #-------------------------------------------------------------------------- def apply_item_effects_set(user, item, targets) targets.each{|target| alive_flag = target.alive? final = target.final_counter(item) if alive_flag target.result.final_counter = true if final target.finish_cond target.target_num = @target_num #1.32テスト実装 target.item_apply(user, item) refresh_status @log_window.display_action_results(target, item) #反動処理 self_reaction_process(user, target.result.hp_damage, item) #ダメージ反射処理 reflection_dmg_process(user, target, target.result.hp_damage, item) if target.dead? && alive_flag target.finish_cond[1] = item target.finish_cond[2] = user if final counter_attack_process(target, user, item, final, 1) @log_window.clear target.perform_collapse_effect end auto_revive_process(target, 0) end target.result.final_counter = false } end #-------------------------------------------------------------------------- # □ 反撃の発動(再定義) #-------------------------------------------------------------------------- def invoke_counter_attack(target, item) return if target.dead? elements = @subject.basic_element_list(@subject, item) attack_skill = target.counter_attack_skill_id(item, elements) #反撃モードに応じてターゲット再設定 targets = [@subject] skill = $data_skills[attack_skill[0]] if KURE::Integrate::COUNTER_MODE == 0 target.add_action(skill.id) case skill.scope when 1 ; targets = [@subject] when 7 ; targets = [target] else ; targets = target.current_action.make_targets.compact end end targets.each{|adopt| counter_attack_process(target, adopt, item, attack_skill, 0) } target.delete_action if KURE::Integrate::COUNTER_MODE == 0 end #-------------------------------------------------------------------------- # □ 魔法反射の発動(再定義) #-------------------------------------------------------------------------- def invoke_magic_reflection(user, target, item) @log_window.display_reflection(user, item) @log_window.wait return if reflection_break_process(target, item) user.magic_reflection = true item.effects.each {|effect| user.item_global_effect_apply(effect) } effect_adopter(user, item, [target]) user.magic_reflection = false end #-------------------------------------------------------------------------- # ★ 反撃処理(追加定義) #-------------------------------------------------------------------------- def counter_attack_process(user, target, item, skill_data, mode) skill = $data_skills[skill_data[0]] @log_window.display_counter(user, skill_data, mode) @log_window.wait return if counter_break_process(target, skill) user.result.counter = true item.effects.each {|effect| user.item_global_effect_apply(effect) } effect_adopter(user, skill, [target], mode) user.result.counter = false end #-------------------------------------------------------------------------- # ★ 反撃無効化処理(拡張特徴ID35)(追加定義) #-------------------------------------------------------------------------- def counter_break_process(target, skill) return decide_process_121(35, target, skill) end #-------------------------------------------------------------------------- # ★ 反射無効化処理(拡張特徴ID49)(追加定義) #-------------------------------------------------------------------------- def reflection_break_process(target, skill) return decide_process_121(49, target, skill) end #-------------------------------------------------------------------------- # ★ 追撃無効化処理(拡張特徴ID63)(追加定義) #-------------------------------------------------------------------------- def react_break_process(target, skill) return decide_process_121(63, target, skill) end #-------------------------------------------------------------------------- # ☆ 無効化判定処理(追加定義) #-------------------------------------------------------------------------- def decide_process_121(id, target, skill) target.add_features_object(id).each{|block| next if block[0] != 3 && block[0] != skill.hit_type next if rand(100) >= block[1] @log_window.message_block_view(target, [[id, block[2], target.name, 0]]) return true } return false end #-------------------------------------------------------------------------- # ★ スキル変化処理(拡張特徴ID43)(追加定義) #-------------------------------------------------------------------------- def change_skill_process(user, item) return item unless item.is_a?(RPG::Skill) #スキル変化の処理(拡張ID43) list = user.change_item_obj.select{|block| block[0] == item.id}.sort_by{rand} list.each{|block| next if rand(100) >= block[2] @log_window.wait @log_window.message_block_view(user, [[43, block[3], $data_skills[block[1]].name, 0]]) return $data_skills[block[1]] } return item end #-------------------------------------------------------------------------- # ★ 変換処理(拡張特徴ID96,97)(追加定義) #-------------------------------------------------------------------------- def convert_object_process(target, item) if item.is_a?(RPG::Skill) arr = target.convert_skill_obj ; id = 96 elsif item.is_a?(RPG::Item) arr = target.convert_item_obj ; id = 97 end #スキル変換処理 list = arr.sort_by{rand} list.each{|block| #対象判定 case block[0] when 0 ; next if block[1] != item.id when 1 ; next if !@subject.basic_element_list(@subject, item).include?(block[1]) when 2 ; next if block[1] != 3 && block[1] != item.hit_type end #確率判定 next if rand(100) >= block[3] @log_window.wait @log_window.message_block_view(target, [[id, block[4], $data_skills[block[2]].name, 0]]) return $data_skills[block[2]] } return item end #-------------------------------------------------------------------------- # ★ 行動変化処理(拡張特徴ID44)(追加定義) #-------------------------------------------------------------------------- def change_action_process(user, item) user.change_action_obj.each{|block| next if rand(100) >= block[1] @log_window.wait @log_window.message_block_view(user, [[44, block[2], [user.name, $data_skills[block[0]].name], 0]]) return $data_skills[block[0]] } return item end #-------------------------------------------------------------------------- # ★ 行動反応追撃発動(拡張特徴ID53)(追加定義) #-------------------------------------------------------------------------- def invoke_reaction_attack(user, item, target) return if target.dead? group = user.friends_unit.members.select{|battler| battler != user} group.each{|battler| next if !battler.alive? or !battler.movable? battler.react_obj.each{|block| next if !battler.opposite?(target) && block[0] < 2 next if battler.opposite?(target) && block[0] == 2 next if rand(100) >= block[3] case block[0] when 0 ; next if item.damage.element_id != block[1] when 1 ; next if item.hit_type != block[1] && block[1] != 3 end skill = $data_skills[block[2]] @log_window.message_block_view(battler, [[53, block[4], [battler.name, skill.name], 0]]) return if react_break_process(target, skill) skill.effects.each {|effect| battler.item_global_effect_apply(effect) } effect_adopter(battler, skill, [target]) @log_window.back_one break } } end #-------------------------------------------------------------------------- # ★ 戦闘行動の実行(拡張ID55)(追加定義) #-------------------------------------------------------------------------- def special_invoke_process(id) return if $game_temp.first_invoke && id == 0 $game_temp.first_invoke = true if id == 0 all_battle_members.each{|battler| battler.special_invoke(id).each{|block| next if !battler.alive? or !battler.movable? next if rand(100) >= block[2] @subject = battler skill = skill = $data_skills[block[1]] case id when 0 ; @status_window.unselect ; @status_window.open when 1,2 ; keep_action = Marshal.load(Marshal.dump(@subject.current_action)) if @subject.current_action end case block[3] when 0 @subject.make_actions unless @subject.current_action @subject.current_action.item_set(skill) when 1 @subject.force_action_item_reset(skill.id) end use_item_no_cost @log_window.wait_and_clear case id when 1,2 @subject.set_action(0, keep_action) if keep_action && @subject.current_action end refresh_status @subject = nil } } end #-------------------------------------------------------------------------- # ★ 特殊追撃発動(拡張特徴ID67)(追加定義) #-------------------------------------------------------------------------- def invoke_chase_attack(user) user.opponents_unit.members.each{|battler| next if !battler.alive? or !user.movable? user.special_chase.each{|block| next unless battler.state?(block[0]) next if rand(100) >= block[2] skill = $data_skills[block[1]] @log_window.message_block_view(battler, [[67, block[3], [user.name, skill.name], 0]]) return if react_break_process(battler, skill) skill.effects.each {|effect| battler.item_global_effect_apply(effect) } effect_adopter(user, skill, [battler]) @log_window.back_one break } } end #-------------------------------------------------------------------------- # ★ 反動処理(追加定義) #-------------------------------------------------------------------------- def self_reaction_process(user, damage, item) return if item.self_react == [0,0,0] keep_hp = user.hp user.self_react_process(item, damage) refresh_status @log_window.message_block_view(user, [[57, 0, [user.name, keep_hp - user.hp], 2]]) if user.alive? && keep_hp - user.hp > 0 @log_window.message_block_view(user, [[57, 1, [user.name], 2]]) if user.dead? end #-------------------------------------------------------------------------- # ★ ダメージ反射処理(追加定義) #-------------------------------------------------------------------------- def reflection_dmg_process(user, target, damage, item) return if damage <= 0 #攻撃属性を取得 elements = user.basic_element_list(user, item) #反射率を取得 rate = target.reflection_rate(item, elements) rate *= 100 return if rate == 0 return if rand(100) >= rate total_damage = target.apply_reflection_dmg_rate(damage, user) user.reflection_dmg_process(item, damage) refresh_status @log_window.message_block_view(user, [[99, 0, [user.name, total_damage], 0]]) if user.alive? @log_window.message_block_view(user, [[99, 1, [user.name], 0]]) if user.dead? end #-------------------------------------------------------------------------- # ★ スキル発動後処理(追加定義) #-------------------------------------------------------------------------- def after_use_item(user, item) user.result.clear #拡張特徴ID68(自爆耐性) if item.life_cost? flag = 0 user.resist_life_obj.each{|block| next if rand(100) >= block[0] user.hp = 1 ; flag = 1 @log_window.message_block_view(user, [[68, block[1], [user.name], 0]]) break } user.pay_life(item) if flag == 0 end #発動後ステート item.after_add_state.each{|id| user.add_state(id)} @log_window.display_added_states(user) skill_lost_process(user, item) #ロストスキル refresh_status wait_for_effect end #-------------------------------------------------------------------------- # ★ ロストスキルの実行(拡張ID37)(追加定義) #-------------------------------------------------------------------------- def skill_lost_process(user, item) return unless item.is_a?(RPG::Skill) return unless item.lost_skill? return unless item.lost_skill?[0] > rand(100) return unless user.actor? return unless user.skill_learn?(item) user.forget_skill(item.id) @log_window.message_block_view(user, [[37, item.lost_skill?[1], [user.name, item.name], 2]]) end #-------------------------------------------------------------------------- # ★ 自動復活の実行(拡張ID64)(追加定義) #-------------------------------------------------------------------------- def auto_revive_process(target, count) #ターン経過 list = target.ad_counter[1] list.each_with_index{|block, index| list[index][0] -= count } #判定処理 list.each_with_index{|block, index| next if block[0] > 0 next if rand(100) >= block[2] next if block[1] < 1 list[index][0] += block[5] list[index][1] -= 1 target.remove_state(target.death_state_id) target.hp = 1 target.hp += (target.mhp * block[3].to_f / 100).to_i show_normal_animation([target], KURE::Integrate::AUTO_RIVIVE_ANIMATION) wait_for_animation @log_window.add_text("") @log_window.display_removed_states(target) if block[1] == 0 target.erase_state(block[4]) if block[4] != 0 target.ad_counter[1][index] = nil end target.ad_counter[1].compact! target.result.clear return } end #-------------------------------------------------------------------------- # ★ ディレイステートの実行(拡張ID66)(追加定義) #-------------------------------------------------------------------------- def delay_state_process(target) #ターン経過 target.result.clear list = target.ad_counter[2] list.each_with_index{|block, index| list[index][1] -= 1 next unless list[index][1] == 0 target.add_state(list[index][0]) @log_window.display_added_states(target) target.perform_collapse_effect if list[index][0] == target.death_state_id target.ad_counter[2][index] = nil } target.result.clear target.ad_counter[2].compact! end #-------------------------------------------------------------------------- # ★ トラップ発動(スキル能力ID18)(追加定義) #-------------------------------------------------------------------------- def invoke_trap(user, item, target) return if item.impossible_trap > rand(100) #トラップ無効スキルは処理しない return unless target.opposite?(user) # 味方には反撃しない list = target.ad_counter[3] list.each_with_index{|block, index| next if block[0] != 3 && block[0] != item.hit_type next if rand(100) >= block[1] trapper = block[6] skill = $data_skills[block[2]] @log_window.message_block_view(trapper, [[18, block[5], [skill.name], 2]]) skill.effects.each {|effect| trapper.item_global_effect_apply(effect) } effect_adopter(trapper, skill, [user]) list[index][3] -= 1 #回数消費 if list[index][3] == 0 target.erase_state(block[4]) if block[4] != 0 list[index] = nil end break } target.ad_counter[3].compact! end #-------------------------------------------------------------------------- # ★ 連鎖発動の追加(スキル能力ID30)(追加定義) #-------------------------------------------------------------------------- def chain_action_process(item) result = [] item.chain_action.each{|block| next if rand(100) >= block[1] result.push($data_skills[block[0]])} return result end #-------------------------------------------------------------------------- # ● 連携発動プロセス(スキル能力ID41)(追加定義) #-------------------------------------------------------------------------- def team_attack_process(item) return unless item.is_a?(RPG::Skill) return if item.team_action == [] team_member = @subject.friends_unit.members item.team_action.each{|block| next if rand(100) >= block[1] team_member.each{|battler| next if battler == @subject next unless battler.alive? next unless battler.movable? battler.actions.each_with_index{|action, index| next unless action if action.item == $data_skills[block[0]] battler.clear_select_action(index) return [battler, $data_skills[block[0]] ,$data_skills[block[2]], block[3]] end } } } return nil end #-------------------------------------------------------------------------- # ★ ステート対応スキル変化処理(スキル能力ID53)(追加定義) #-------------------------------------------------------------------------- def state_change_process(target, item) return item unless item.is_a?(RPG::Skill) state_list = [] target.each{|battler| state_list += battler.state_ids} state_list.sort_by{rand} item.state_change_skill.each{|block| next unless state_list.include?(block[0]) @log_window.wait @log_window.message_block_view(target, [[54, block[2], [$data_states[block[0]].name], 2]]) return $data_skills[block[1]] } return item end #-------------------------------------------------------------------------- # ★ アニメーションの表示(汎用)(追加定義) #-------------------------------------------------------------------------- def show_animation_set(targets, user, item) item.multi_anim_effect.each{|id| if id < 0 show_attack_animation_set(targets, user) else show_normal_animation(targets, id) end wait_for_animation } @log_window.wait wait_for_animation end #-------------------------------------------------------------------------- # ★ 攻撃アニメーションの表示(汎用)(追加定義) #-------------------------------------------------------------------------- def show_attack_animation_set(targets, user) if user.actor? show_normal_animation(targets, user.atk_animation_id1, false) show_normal_animation(targets, user.atk_animation_id2, true) else Sound.play_enemy_attack abs_wait_short end end #-------------------------------------------------------------------------- # ★ 外部コールのスキル使用(追加定義) #-------------------------------------------------------------------------- def call_skill(item) @notime_skill = false @skill = item if @skill.no_time_effect @subject = BattleManager.actor @notime_object = true if !@skill.need_selection? notime_skill_process(@subject, @skill) elsif @skill.for_opponent? select_enemy_selection else select_actor_selection end else BattleManager.actor.input.set_skill(@skill.id) BattleManager.actor.last_skill.object = @skill if !@skill.need_selection? @skill_window.hide @item_window.hide next_command elsif @skill.for_opponent? select_enemy_selection else select_actor_selection end end end #-------------------------------------------------------------------------- # ◎ スキル［決定］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_skill_ok :on_skill_ok unless $! def on_skill_ok @notime_skill = false @skill = @skill_window.item if @skill.no_time_effect @subject = BattleManager.actor @notime_skill = true if !@skill.need_selection? notime_skill_process(@subject, @skill) elsif @skill.for_opponent? select_enemy_selection else select_actor_selection end else k_integrate_before_on_skill_ok end end #-------------------------------------------------------------------------- # ◎ スキル［キャンセル］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_skill_cancel :on_skill_cancel unless $! def on_skill_cancel @notime_skill = false k_integrate_before_on_skill_cancel end #-------------------------------------------------------------------------- # ◎ アイテム［決定］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_item_ok :on_item_ok unless $! def on_item_ok $game_temp.add_reserve_log(@item_window.item, BattleManager.actor_index) @notime_item = false #効果発動する装備品は該当のスキルをセット if @item_window.item.is_a?(RPG::EquipItem) call_skill($data_skills[@item_window.item.skill_effect_id]) return else #通常のアイテムの処理 @item = @item_window.item end if @item.no_time_effect @subject = BattleManager.actor BattleManager.actor.input.set_item(@item.id) @notime_item = true if !@item.need_selection? notime_skill_process(@subject, @item) elsif @item.for_opponent? select_enemy_selection else select_actor_selection end else k_integrate_before_on_item_ok end end #-------------------------------------------------------------------------- # ◎ アイテム［キャンセル］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_item_cancel :on_item_cancel unless $! def on_item_cancel $game_temp.add_reserve_log(nil, BattleManager.actor_index) @notime_item = false k_integrate_before_on_item_cancel end #-------------------------------------------------------------------------- # ◎ アクター［決定］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_actor_ok :on_actor_ok unless $! def on_actor_ok if @notime_skill notime_skill_process(@subject, @skill, @actor_window.index) elsif @notime_item notime_skill_process(@subject, @item, @actor_window.index) else k_integrate_before_on_actor_ok end end #-------------------------------------------------------------------------- # ◎ 敵キャラ［決定］(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_enemy_ok :on_enemy_ok unless $! def on_enemy_ok if @notime_skill notime_skill_process(@subject, @skill, @enemy_window.enemy.index) elsif @notime_item notime_skill_process(@subject, @item, @enemy_window.enemy.index) else k_integrate_before_on_enemy_ok end end #-------------------------------------------------------------------------- # ◎ 即時発動プロセス(追加定義) #-------------------------------------------------------------------------- def notime_skill_process(actor, skill, target = nil) #行動不可アクターの配列を取得 no_action_unit = all_battle_members.select{|battler| !battler.movable?} @actor_window.hide ; @enemy_window.hide @skill_window.hide ; @item_window.hide @notime_skill = false ; @notime_item = false @subject = actor no_time_skill = Game_Action.new(@subject) no_time_skill.item = skill no_time_skill.target_index = target if target @subject.add_current_action(no_time_skill) execute_action if @subject.current_action.valid? @subject.reinput_command @subject = nil #行動不可アクターの配列を比較 no_action_unit.each{|battler| battler.make_actions if battler.movable?} if BattleManager.in_phase? @status_window.open next_command end end #-------------------------------------------------------------------------- # ● 前のコマンド入力へ(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_prior_command :prior_command unless $! def prior_command k_integrate_before_prior_command $game_temp.add_reserve_log(nil, BattleManager.actor_index) end end #============================================================================== # ■ Sprite_Base #============================================================================== class Sprite_Base < Sprite #-------------------------------------------------------------------------- # ● アニメーションの速度を設定 #-------------------------------------------------------------------------- def set_animation_rate @ani_rate = $game_party.in_battle ? (4 / KURE::Integrate::ANIM_SPEED).to_i : 4 end end #============================================================================== # ■ Game_Action #============================================================================== class Game_Action #-------------------------------------------------------------------------- # ★ スキル/アイテムオブジェクトを設定(追加定義) #-------------------------------------------------------------------------- def item_set(item) @item.object = item ; self end #-------------------------------------------------------------------------- # ◎ ターゲットの配列作成(エイリアス) #-------------------------------------------------------------------------- alias :k_integrate_before_make_targets :make_targets unless $! def make_targets base_target = k_integrate_before_make_targets new_target = file_target(base_target) new_target = state_target(new_target) return new_target end #-------------------------------------------------------------------------- # ★ スキル能力ID60(対象隊列を返す) #-------------------------------------------------------------------------- def file_target(base_target) return base_target if item.target_file == [] result_target = Array.new base_target.each_with_index{|battler, index| result_target.push(battler) if item.target_file.include?(index + 1) } return result_target end #-------------------------------------------------------------------------- # ★ スキル能力ID52(ターゲットステートの対象を返す) #-------------------------------------------------------------------------- def state_target(base_target) return base_target if item.target_state == [] result_target = Array.new base_target.each{|battler| item.target_state.each{|id| next unless battler.state?(id) result_target.push(battler) break } } return result_target end end #============================================================================== # ■ BattleManager #============================================================================== class << BattleManager #-------------------------------------------------------------------------- # ★戦闘フェイズの存在判定(追加定義) #-------------------------------------------------------------------------- def in_phase? return true if @phase return false end #-------------------------------------------------------------------------- # ★アクターのINDEXを返す(追加定義) #-------------------------------------------------------------------------- def actor_index return @actor_index >= 0 ? @actor_index : nil end end