#============================================================================== # ■統合ベーススクリプトＡ for RGSS3 Ver2.23-β #　□作成者 kure # #　拡張特徴及びパッシブスキルに関するスクリプト群です。 # #============================================================================== $kure_integrate_script = {} if $kure_integrate_script == nil $kure_integrate_script[:integrate] = 100 p "統合ベーススクリプトＡ" #============================================================================== # ■ Window_BattleLog #============================================================================== class Window_BattleLog < Window_Selectable #-------------------------------------------------------------------------- # □ 行動結果の表示(再定義) #-------------------------------------------------------------------------- def display_action_results(target, item) if target.result.used last_line_number = line_number display_critical(target, item) display_invalidate(target, item) display_deffence(target, item) display_damage(target, item) display_affected_status(target, item) display_failure(target, item) display_after_message(target, item) wait if line_number > last_line_number back_to(last_line_number) end end #-------------------------------------------------------------------------- # ☆ 失敗の表示(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_before_display_failure :display_failure unless $! def display_failure(target, item) return if target.result.invalidate? k_before_display_failure(target, item) end #-------------------------------------------------------------------------- # ☆ ダメージの表示(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_before_display_damage :display_damage unless $! def display_damage(target, item) return if target.result.invalidate? k_before_display_damage(target, item) end #-------------------------------------------------------------------------- # □ ステート変更のの表示(再定義) #-------------------------------------------------------------------------- def display_changed_states(target) display_added_states(target) display_removed_states(target) if target.alive? end #-------------------------------------------------------------------------- # □ ステート付加の表示(再定義) #-------------------------------------------------------------------------- def display_added_states(target) target.result.added_state_objects.each do |state| next if state.id == target.death_state_id && target.result.final_counter state_msg = target.actor? ? state.message1 : state.message2 target.perform_collapse_effect if state.id == target.death_state_id next if state_msg.empty? replace_text(target.name + state_msg) wait ; wait_for_effect end end #-------------------------------------------------------------------------- # □ 反撃の表示(再定義) #-------------------------------------------------------------------------- def display_counter(target, item, mode = 0) Sound.play_evasion skill = $data_skills[item[0]] ; msg = mode == 0 ? 34 : 41 fmt = (skill.id == 1) ? Vocab::CounterAttack : Vocab.set_format(msg, item[1]) block = (skill.id == 1) ? [target.name] : [target.name, skill.name] add_text(fmt%(block)) end #-------------------------------------------------------------------------- # □ 反射の表示(再定義) #-------------------------------------------------------------------------- def display_reflection(target, item) Sound.play_reflection case item.hit_type when 0 ; fmt = Vocab::CertainRflection when 1 ; fmt = Vocab::PhysicalReflection when 2 ; fmt = Vocab::MagicReflection end add_text(sprintf(fmt, target.name)) ; wait end #-------------------------------------------------------------------------- # ★ 無効化の表示(追加定義) #-------------------------------------------------------------------------- def display_invalidate(target, item) return unless target.result.invalidate? message_block_view(target, target.result.add_feature_invalidate) end #-------------------------------------------------------------------------- # ★ 防御の表示(追加定義) #-------------------------------------------------------------------------- def display_deffence(target, item) return unless target.result.deffence? message_block_view(target, target.result.add_feature_deffence) end #-------------------------------------------------------------------------- # ★ 効果後のメッセージの表示(追加定義) #-------------------------------------------------------------------------- def display_after_message(target, item) return unless target.result.after_message? message_block_view(target, target.result.add_feature_after) end #-------------------------------------------------------------------------- # ★ 設定されたブロックメッセージを表示(拡張特徴用)(追加定義) #-------------------------------------------------------------------------- def message_block_view(target, message) message.each{|block| next if block[1] == -1 case block[3] when 0 next if block[1] < 0 fmt = Vocab.set_format(block[0], block[1]) add_text(fmt%(block[2])) ; wait when 1 ; display_changed_states(block[0]) when 2 fmt = Vocab.set_skill_format(block[0], block[1]) add_text(fmt%(block[2])) ; wait end } end end #============================================================================== # ■ Window_SkillList #============================================================================== class Window_SkillList < Window_Selectable #-------------------------------------------------------------------------- # □ スキルをリストに含めるかどうか(再定義) #-------------------------------------------------------------------------- def include?(item) return false if item.view_mode == 3 return false if item.view_mode == 1 && !$game_party.in_battle return false if item.view_mode == 2 && $game_party.in_battle return true if item && item.stype_id == @stype_id return true if item.add_skill_type.include?(@stype_id) return false end #-------------------------------------------------------------------------- # ◎ スキルの使用コストを描画(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_draw_skill_cost :draw_skill_cost unless $! def draw_skill_cost(rect, skill) if @actor.delay_time(skill) != 0 change_color(power_down_color) draw_text(rect, "Delay " + @actor.delay_time(skill).to_s, 2) else k_integrate_before_draw_skill_cost(rect, skill) end end end #============================================================================== # ■ Window_ActorCommand #============================================================================== class Window_ActorCommand < Window_Command #-------------------------------------------------------------------------- # ● スキルコマンドをリストに追加 #-------------------------------------------------------------------------- def add_skill_commands @actor.added_skill_types.sort.each do |stype_id| next if KURE::Integrate::HIDE_SKILL_TYPE.include?(stype_id) data = @actor ? @actor.skills.select {|skill| include_cheack?(skill, stype_id)} : [] next if data == [] && KURE::Integrate::HIDE_SKILL_TYPE_MODE == 1 name = $data_system.skill_types[stype_id] add_command(name, :skill, true, stype_id) end end #-------------------------------------------------------------------------- # ● スキルをリストに含まれているかどうか #-------------------------------------------------------------------------- def include_cheack?(item, stype_id) return false if item.view_mode == 2 or item.view_mode == 3 return true if item && item.stype_id == stype_id return true if item.add_skill_type.include?(stype_id) return false end end #============================================================================== # ★ Vocab(追加定義) #============================================================================== module Vocab #-------------------------------------------------------------------------- # ★ メッセージのフォーマットを返す(追加定義) #-------------------------------------------------------------------------- def self.set_format(f_id, m_id) return "" unless ADD_MESSEAGE[f_id] return ADD_MESSEAGE[f_id][0] unless ADD_MESSEAGE[f_id][m_id] return ADD_MESSEAGE[f_id][m_id] end #-------------------------------------------------------------------------- # ★ スキルメッセージのフォーマットを返す(追加定義) #-------------------------------------------------------------------------- def self.set_skill_format(f_id, m_id) return "" if !SKILL_MESSEAGE[f_id] or !SKILL_MESSEAGE[f_id][m_id] return SKILL_MESSEAGE[f_id][m_id] end end #============================================================================== # ■ Game_Unit #============================================================================== class Game_Unit attr_accessor :dead_num #戦闘不能者数 #-------------------------------------------------------------------------- # ★ 戦闘不能者数を取得(追加定義) #-------------------------------------------------------------------------- def set_dead_num @dead_num = dead_members.size end #-------------------------------------------------------------------------- # ★ 戦闘不能者数を取得(追加定義) #-------------------------------------------------------------------------- def dead_num @dead_num ? @dead_num : 0 end #-------------------------------------------------------------------------- # ◎ 戦闘開始処理(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_battle_start :on_battle_start unless $! def on_battle_start set_dead_num k_integrate_before_on_battle_start end #-------------------------------------------------------------------------- # ◎ 戦闘終了処理(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_battle_end :on_battle_end unless $! def on_battle_end @dead_num = 0 k_integrate_before_on_battle_end end end #============================================================================== # ■ Game_Party #============================================================================== class Game_Party < Game_Unit attr_accessor :ad_data #拡張特徴オブジェクト attr_accessor :refresh_flag #拡張特徴オブジェクト初期化判定 #-------------------------------------------------------------------------- # ◎ オブジェクト初期化(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_initialize :initialize unless $! def initialize k_integrate_before_initialize @ad_data = [] ; @party_note_data = "" ; @refresh_flag = [] end #-------------------------------------------------------------------------- # ★ パーティー全員のメモ欄(追加定義) #-------------------------------------------------------------------------- def party_note return @party_note_data if @refresh_flag != [] @party_note_data = "" battle_members.each{|actor| @party_note_data += actor.passive_note} return @party_note_data end #-------------------------------------------------------------------------- # ★ パーティー全体へ影響するパッシブスキル #-------------------------------------------------------------------------- def party_encounter_rate ; party_passive(0) ; end #拡張特徴ID69(エンカウント率) def party_drop_rate ; party_passive(1) ; end #拡張特徴ID70(ドロップ率) def party_gold_rate ; party_passive(2) ; end #拡張特徴ID71(獲得金額率) #-------------------------------------------------------------------------- # ★ パーティー用拡張オブジェクトの呼び出し(追加定義) #-------------------------------------------------------------------------- def party_passive(id) case id when 0 ; passive_id = 69 when 1 ; passive_id = 70 when 2 ; passive_id = 71 end return @ad_data[id] if @refresh_flag[id] @ad_data[id] = KURE.call_add_feature(passive_id, party_note) @refresh_flag[id] = 1 return @ad_data[id] end end #============================================================================== # ■ Game_Troop #============================================================================== class Game_Troop < Game_Unit #-------------------------------------------------------------------------- # ◎ お金の倍率を取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_gold_rate :gold_rate unless $! def gold_rate k_integrate_before_gold_rate * $game_party.party_gold_rate end #-------------------------------------------------------------------------- # ◎ お金の合計計算(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_gold_total :gold_total unless $! def gold_total k_integrate_before_gold_total.to_i end #-------------------------------------------------------------------------- # ☆ アビリティポイントの合計計算(追加定義) #-------------------------------------------------------------------------- def ability_exp_total ability_exp_total = dead_members.inject(0) {|r, enemy| r += enemy.ability_exp } return ability_exp_total.to_i end end #============================================================================== # ■ Game_Player #============================================================================== class Game_Player < Game_Character #-------------------------------------------------------------------------- # ◎ エンカウント進行値の取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_encounter_progress_value :encounter_progress_value unless $! def encounter_progress_value k_integrate_before_encounter_progress_value * $game_party.party_encounter_rate end end #============================================================================== # ■ Game_BattlerBase #============================================================================== class Game_BattlerBase #-------------------------------------------------------------------------- # ● ステートIDのリストを取得(追加定義) #-------------------------------------------------------------------------- def state_ids @states end #-------------------------------------------------------------------------- # ◎ 通常能力値の加算値取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_param_plus :param_plus unless $! def param_plus(param_id) result = k_integrate_before_param_plus(param_id) + add_param_value(param_id) result += param_base(param_id) * adversity_cut_rate[2] * friends_unit.dead_num if param_id != 0 && param_id != 1 result += variables_revise(param_id) return result end #-------------------------------------------------------------------------- # ◎ 能力値に加算する値をクリア(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_clear_param_plus :clear_param_plus unless $! def clear_param_plus k_integrate_before_clear_param_plus @param_plus_ex = [0] * 8 end #-------------------------------------------------------------------------- # ★ 能力値の加算呼び出し(スキル能力ID32)(追加定義) #-------------------------------------------------------------------------- def add_param_cost(param_id, value) add_param(param_id, value) if param_id <= 7 add_param_ex(param_id - 8, value) if param_id > 7 end #-------------------------------------------------------------------------- # ★ 能力値の加算(拡張)(追加定義) #-------------------------------------------------------------------------- def add_param_ex(param_id, value) #ID0 TP補正値 @param_plus_ex[param_id] += value refresh end #-------------------------------------------------------------------------- # ◎ TP の最大値を取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_max_tp :max_tp unless $! def max_tp [((100 + @param_plus_ex[0]) * tp_revise[1]) + tp_revise[0], 0].max end #-------------------------------------------------------------------------- # □ TP の割合を取得(再定義) #-------------------------------------------------------------------------- def tp_rate max_tp > 0 ? @tp.to_f / max_tp : 0 end end #============================================================================== # ■ Game_Battler #============================================================================== class Game_Battler < Game_BattlerBase attr_accessor :ad_counter #拡張特徴カウントオブジェクト attr_accessor :finish_cond #戦闘不能時の状況オブジェクト attr_accessor :target_num #現在の攻撃対象数 #-------------------------------------------------------------------------- # ★ 拡張特徴オブジェクトのカウンターをセット(追加定義) #-------------------------------------------------------------------------- def make_add_feature_counter @ad_counter = [] @ad_counter[0] = invalidate_def_wall #防御壁展開オブジェクト @ad_counter[1] = auto_revive #自動復活オブジェクト @ad_counter[2] = delay_state #ディレイステートオブジェクト @ad_counter[3] = [] #トラップ設置 @ad_counter[4] = [] #身代わり @ad_counter[5] = [] #スキルディレイ @finish_cond = [] @finish_cond[0] = [] #直前のステート @finish_cond[1] = nil #直前のスキル @finish_cond[2] = nil #スキル発動者 end #-------------------------------------------------------------------------- # ★ 拡張特徴オブジェクトのカウンターをリセット(追加定義) #-------------------------------------------------------------------------- def clear_add_effect return unless @ad_counter @ad_counter[0] = [] @ad_counter[2] = [] @ad_counter[3] = [] @ad_counter[4] = [] end #-------------------------------------------------------------------------- # ◎ リフレッシュ(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_refresh :refresh unless $! def refresh if caller[0][/`([^']*)'/, 1] == "force_change_equip" force_refresh else @need_refresh = false k_integrate_before_refresh @need_refresh = true set_passive_object end end #-------------------------------------------------------------------------- # ◎ 強制装備変更時リフレッシュ(エイリアス再定義) #-------------------------------------------------------------------------- def force_refresh @need_refresh = false state_resist_set.each {|state_id| erase_state(state_id) } @hp = [[@hp, mhp].min, 0].max @mp = [[@mp, mmp].min, 0].max @hp == 0 ? add_state(death_state_id) : remove_state(death_state_id) @need_refresh = true set_passive_object(false) end #-------------------------------------------------------------------------- # ◎ ステートの付加可能判定(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_state_addable? :state_addable? unless $! def state_addable?(state_id) k_integrate_before_state_addable?(state_id) && !auto_list_ex.include?(state_id) end #-------------------------------------------------------------------------- # ◎ ステートの付加(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_add_state :add_state unless $! def add_state(state_id) @need_refresh = false return unless state_multi_addable?(state_id)#重複許容処理 return unless pre_state_process(state_id) #前提ステート処理 return if offset_state_process(state_id, 0) #相殺ステート処理 offset_state_process(state_id, 1) #上書きステート処理 state_id = state_change_process(state_id) #ステート変化処理 return if state?(state_id) && $data_states[state_id].overwrite_mode == 2 k_integrate_before_add_state(state_id) #処理本体 @need_refresh = true set_passive_object unless $data_states[state_id].not_passive_refresh end #-------------------------------------------------------------------------- # ◎ 新しいステートの付加(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_add_new_state :add_new_state unless $! def add_new_state(state_id) k_integrate_before_add_new_state(state_id) state_feature_process(state_id, 0) end #-------------------------------------------------------------------------- # □ ステートのカウント（ターン数および歩数）をリセット(再定義) #-------------------------------------------------------------------------- def reset_state_counts(state_id) state = $data_states[state_id] variance = 1 + [state.max_turns - state.min_turns, 0].max case state.overwrite_mode when 0,2 @state_turns[state_id] = state.min_turns + rand(variance) @state_steps[state_id] = state.steps_to_remove when 1 @state_turns[state_id] ||= 0 ; @state_steps[state_id] ||= 0 @state_turns[state_id] += state.min_turns + rand(variance) @state_steps[state_id] += state.steps_to_remove end end #-------------------------------------------------------------------------- # ◎ ステートの消去(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_erase_state :erase_state unless $! def erase_state(state_id) return unless @states.include?(state_id) k_integrate_before_erase_state(state_id) $data_states[state_id].next_state.each{|id| add_state(id)} set_passive_object unless $data_states[state_id].not_passive_refresh state_feature_process(state_id, 1) end #-------------------------------------------------------------------------- # ★ ステートによる追加特徴の発動(追加定義)(task 0：付与　1:解除) #-------------------------------------------------------------------------- def state_feature_process(id, task) case task when 0 #ID62(防御壁展開) @ad_counter[0] += KURE.call_add_feature(62, $data_states[id].note) #ID64(自動復活) @ad_counter[1] += KURE.call_add_feature(64, $data_states[id].note) #ID66(ディレイステート) @ad_counter[2] += KURE.call_add_feature(66, $data_states[id].note) when 1 #ID62(防御壁展開) @ad_counter[0].delete_if {|block| block[3] == id} #ID64(自動復活) @ad_counter[1].delete_if {|block| block[4] == id} #ID66(ディレイステート) @ad_counter[2].delete_if {|block| block[2] == id} #ID18トラップ設置 @ad_counter[3].delete_if {|block| block[4] == id} #ID34身代わり対象 @ad_counter[4].delete_if {|block| block[2] == id} end end #-------------------------------------------------------------------------- # ★ 指定IDの能力値変化の値取得(拡張特徴ID0)(追加定義) #-------------------------------------------------------------------------- def add_param_value(param_id) add_features_object(0)[param_id] ? add_features_object(0)[param_id] : 0 end #-------------------------------------------------------------------------- # ★ オートステート発動(拡張特徴ID28)(追加定義) #-------------------------------------------------------------------------- def auto_state_adder @need_refresh = false auto_list.each {|state| erase_state_no_next(state) ; add_new_state(state) ; reset_state_counts(state)} @need_refresh = true end #-------------------------------------------------------------------------- # ★ 解除時判定を伴わないステートの消去(追加定義) #-------------------------------------------------------------------------- def erase_state_no_next(state_id) k_integrate_before_erase_state(state_id) state_feature_process(state_id, 1) end #-------------------------------------------------------------------------- # ★ オートステートをオブジェクトの配列で取得(拡張特徴ID29)(追加定義) #-------------------------------------------------------------------------- def auto_states_ex_obj auto_list_ex.collect {|id| $data_states[id] } end #-------------------------------------------------------------------------- # □ 現在のステートをアイコン番号の配列で取得(拡張特徴ID29)(再定義) #-------------------------------------------------------------------------- def state_icons icons = states.collect {|state| state.icon_index } icons += auto_states_ex_obj.collect {|state| state.icon_index } icons.delete(0) icons end #-------------------------------------------------------------------------- # ★ ステート変換プロセス(拡張特徴ID50)(追加定義) #-------------------------------------------------------------------------- def state_change_process(state_id) list = state_change_obj.select{|block| block[0] == state_id}.sort_by{rand} list.each{|block| next if rand(100) >= block[2] @result.add_feature_deffence.push([50, block[3], [name], 0]) return block[1] } return state_id end #-------------------------------------------------------------------------- # ★ トリガーステートプロセス(拡張特徴ID65)(追加定義) #-------------------------------------------------------------------------- def trigger_state_process trigger_state.each{|block| case block[1] when 0,1 ; next if state?(block[4]) when 2,3 ; next unless state?(block[4]) end case block[0] when 0; value = hp ; rate = mhp * (block[2].to_f / 100) + block[3] when 1; value = mp ; rate = mmp * (block[2].to_f / 100) + block[3] when 2; value = tp ; rate = max_tp * (block[2].to_f / 100) + block[3] end case block[1] when 0,2 ; next if value < rate when 1,3 ; next if value >= rate end case block[1] when 0,1 ; add_state(block[4]) when 2,3 ; erase_state(block[4]) end } end #-------------------------------------------------------------------------- # ★ ターン終了時のカウント処理(追加定義) #-------------------------------------------------------------------------- def turn_increase_process #身代わり対象の時間経過 @ad_counter[4].each_with_index{|block, index| next unless block block[3] -= 1 next unless block[3] < 0 erase_state(block[2]) if block[2] != 0 @ad_counter[4][index] = nil} @ad_counter[4].compact! delay_counter(1) #スキルディレイの時間経過 end #-------------------------------------------------------------------------- # ★ スキルディレイの時間経過(追加定義) #-------------------------------------------------------------------------- def delay_counter(count) return if count == 0 @ad_counter[5].each_with_index{|block, index| next unless block next if block[0] < - 99 block[0] -= count @ad_counter[5][index] = nil if block[0] < 1} @ad_counter[5].compact! end #-------------------------------------------------------------------------- # ★ 前提ステートチェック(追加定義) #-------------------------------------------------------------------------- def pre_state_process(state_id) list = $data_states[state_id].basic_state return true if list == [] cheak_list = @states + auto_list_ex list.each{|id| return true if cheak_list.include?(id)} return false end #-------------------------------------------------------------------------- # ★ 相殺ステート操作(追加定義) #-------------------------------------------------------------------------- def offset_state_process(state_id, mode) case mode when 0 ; list = $data_states[state_id].offset_state_type when 1 ; list = $data_states[state_id].overwrite_state_type end state_list = @states.collect {|id| $data_states[id] } offset_flag = 0 list.each{|type| state_list.each{|state| if state.state_type == type erase_state(state.id) offset_flag = 1 end } auto_states_ex_obj.each{|state| offset_flag = 1 if state.state_type == type} } #相殺ステート操作時のみ相殺すればtrueを返す return true if offset_flag == 1 && mode == 0 return false end #-------------------------------------------------------------------------- # ★ ステート重複許容(追加定義) #-------------------------------------------------------------------------- def state_multi_addable?(id) return true unless $data_states[id].multi_addable case $data_states[id].multi_addable[0] when 0 cheak_member = $game_party.members when 1 return true unless $game_party.in_battle cheak_member = $game_troop.members when 2 cheak_member = $game_party.members cheak_member += $game_troop.members if $game_party.in_battle end num = 0 cheak_member.each{|battler| num += 1 if battler.state?(id)} return true if $data_states[id].multi_addable[1] > num return false end #-------------------------------------------------------------------------- # □ 戦闘不能になる(再定義) #-------------------------------------------------------------------------- def die @hp = 0 @finish_cond[0] = states.collect{|state| state.id} if @finish_cond states.each{|state| erase_state(state.id) if !state.not_delete_state} clear_add_effect clear_buffs end #-------------------------------------------------------------------------- # ★ 行動変化オブジェクトターゲット変更(追加定義) #-------------------------------------------------------------------------- def force_action_item_reset(skill_id) clear_actions action = Game_Action.new(self, true) action.set_skill(skill_id) @actions.push(action) end #-------------------------------------------------------------------------- # ◎ 全回復(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_recover_all :recover_all unless $! def recover_all k_integrate_before_recover_all set_passive_object end #-------------------------------------------------------------------------- # ◎ 戦闘開始処理(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_battle_start :on_battle_start unless $! def on_battle_start k_integrate_before_on_battle_start trigger_state_process set_passive_object make_add_feature_counter end #-------------------------------------------------------------------------- # ◎ ターン終了処理(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_on_turn_end :on_turn_end unless $! def on_turn_end k_integrate_before_on_turn_end return unless $game_party.in_battle trigger_state_process turn_increase_process set_passive_object end #-------------------------------------------------------------------------- # ◎ オブジェクト初期化(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_initialize :initialize unless $! def initialize k_integrate_before_initialize set_up_additional_object end #-------------------------------------------------------------------------- # ★ 追加オブジェクトの初期化(追加定義) #-------------------------------------------------------------------------- def set_up_additional_object @need_refresh = true make_passive_cache make_add_feature_counter end #-------------------------------------------------------------------------- # ★ バトラーの全メモ欄を取得(追加定義) #-------------------------------------------------------------------------- def passive_note return @note_cache.join end #-------------------------------------------------------------------------- # ★ パッシブスキルオブジェクトのメモをセット(追加定義) #-------------------------------------------------------------------------- def set_passive_object(force = false) return unless @need_refresh set_battler_note set_state_note if actor? set_equip_note set_skill_note end fix_status release_unequippable_items if force end #-------------------------------------------------------------------------- # ★ ステータスの現在値修正(追加定義) #-------------------------------------------------------------------------- def fix_status @hp = [[@hp, mhp].min, 0].max @mp = [[@mp, mmp].min, 0].max @tp = [[@tp, max_tp].min, 0].max end #-------------------------------------------------------------------------- # ★ ステートのメモをセット(追加定義) #-------------------------------------------------------------------------- def set_state_note return if (@states + auto_list_ex) == @state_cache add = (@states + auto_list_ex) - @state_cache remove = @state_cache - (@states + auto_list_ex) add.each{|id| @data_cache[1].push([id, $data_states[id].note])} remove.each{|id| find = @data_cache[1].find_index{|block| block[0] == id} @data_cache[1].delete_at(find) if find } @state_cache = (@states + auto_list_ex).clone @note_cache[1] = @data_cache[1].collect{|block| block[1]}.join @refresh_flag = [] $game_party.refresh_flag = [] end #-------------------------------------------------------------------------- # ★ 拡張特徴オブジェクトの呼び出し(追加定義) #-------------------------------------------------------------------------- def add_features_object(id) return @add_feature_cache[id] if @refresh_flag[id] @add_feature_cache[id] = KURE.call_add_feature(id, passive_note) @refresh_flag[id] = 1 return @add_feature_cache[id] end #-------------------------------------------------------------------------- # ◎ 特徴を保持する全オブジェクトの配列取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_feature_objects :feature_objects unless $! def feature_objects k_integrate_before_feature_objects + auto_states_ex_obj + multi_class_obj end #-------------------------------------------------------------------------- # ◎ スキル／アイテムの適用テスト(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_item_test :item_test unless $! def item_test(user, item) return true if adv_item_effect_any?(user, item) k_integrate_before_item_test(user, item) end #-------------------------------------------------------------------------- # ★ 拡張スキル能力が存在するかどうか(追加定義) #-------------------------------------------------------------------------- def adv_item_effect_any?(user, item) return true if item.durable_damage != [] return true if item.gain_items != [] return true if item.grow_pram != [] return false end #-------------------------------------------------------------------------- # ◎ スキル／アイテムの共通使用可能条件チェック(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_usable_item_conditions_met? :usable_item_conditions_met? unless $! def usable_item_conditions_met?(item) k_integrate_before_usable_item_conditions_met?(item) && item_usable_skills?(item) end #-------------------------------------------------------------------------- # ◎ アイテムの使用可能条件チェック(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_item_conditions_met? :item_conditions_met? unless $! def item_conditions_met?(item) k_integrate_before_item_conditions_met?(item) && !item_not_usable_state? end #-------------------------------------------------------------------------- # ★ アイテム使用不可ステート判定(追加定義) #-------------------------------------------------------------------------- def item_not_usable_state? states.any? {|state| state.can_not_use_item } end #-------------------------------------------------------------------------- # ★ 必要習得スキル判定(追加定義) #-------------------------------------------------------------------------- def item_usable_skills?(item) return true if item.required_skill == [] item.required_skill.each{|id| return true if skill_learn?($data_skills[id])} return false end #-------------------------------------------------------------------------- # □ スキルの使用可能条件チェック(再定義) #-------------------------------------------------------------------------- def skill_conditions_met?(skill) usable_item_conditions_met?(skill) && skill_wtype_ok?(skill) && skill_cost_payable?(skill) && !skill_sealed?(skill.id) && !skill_type_sealed?(skill) && nodelay?(skill) end #-------------------------------------------------------------------------- # □ スキルタイプ封印の判定（再定義） #-------------------------------------------------------------------------- def skill_type_sealed?(skill) skill.add_skill_type.each{|stype_id| return false unless features_set(FEATURE_STYPE_SEAL).include?(stype_id) } return true if features_set(FEATURE_STYPE_SEAL).include?(skill.stype_id) return false end #-------------------------------------------------------------------------- # ★ スキルのディレイ判定(追加定義) #-------------------------------------------------------------------------- def nodelay?(skill) return true unless $game_party.in_battle return false if @ad_counter[5].any?{|block| block[1] == skill.id} return true end #-------------------------------------------------------------------------- # ★ スキルのディレイ判定(追加定義) #-------------------------------------------------------------------------- def delay_time(skill) return 0 unless $game_party.in_battle value = @ad_counter[5].find{|block| block[1] == skill.id} return 0 unless value return value[0] > 0 ? value[0] : "∞" end #-------------------------------------------------------------------------- # ★ 戦闘行動をセット(追加定義) #------------------------------------------------------------------------- def set_action(id, action) @actions[id] = action end #-------------------------------------------------------------------------- # ★ 先頭に戦闘行動の追加(追加定義) #-------------------------------------------------------------------------- def add_action(id) action = Game_Action.new(self, true) action.set_skill(id) @actions.unshift(action) end #-------------------------------------------------------------------------- # ★ 先頭の戦闘行動の削除(追加定義) #-------------------------------------------------------------------------- def delete_action @actions.shift end end #============================================================================== # ■ Game_ActionResult #============================================================================== class Game_ActionResult attr_accessor :add_feature_invalidate #追加特徴による無効化 attr_accessor :add_feature_deffence #追加特徴によるダメージ減少 attr_accessor :add_feature_after #追加特徴による追加メッセージ attr_accessor :counter #反撃フラグ attr_accessor :final_counter #最終反撃フラグ attr_accessor :stealed #スティール済フラグ attr_accessor :effect_invalidate #追加特徴による効果無効化フラグ #-------------------------------------------------------------------------- # ◎ クリア(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_clear :clear unless $! def clear k_integrate_before_clear clear_add_feature_obj end #-------------------------------------------------------------------------- # ★ 拡張特徴の追加リザルトをクリア(追加定義) #-------------------------------------------------------------------------- def clear_add_feature_obj @add_feature_invalidate = [] @add_feature_deffence = [] @add_feature_after = [] @counter = false @effect_invalidate = false end #-------------------------------------------------------------------------- # ★ 無効化したか否かを判定(追加定義) #-------------------------------------------------------------------------- def invalidate? return false if @add_feature_invalidate == [] return true end #-------------------------------------------------------------------------- # ★ 防御したか否かを判定(追加定義) #-------------------------------------------------------------------------- def deffence? return false if @add_feature_deffence == [] return true end #-------------------------------------------------------------------------- # ★ 防御したか否かを判定(追加定義) #-------------------------------------------------------------------------- def after_message? return false if @add_feature_after == [] return true end end #============================================================================== # ■ Game_Action #============================================================================== class Game_Action #-------------------------------------------------------------------------- # ◎ 通常攻撃判定(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_attack? :attack? unless $! def attack? return true if k_integrate_before_attack? return true if item && item.normal_attack? return false end #-------------------------------------------------------------------------- # ★ アイテムオブジェクト定義(追加定義) #-------------------------------------------------------------------------- def item=(item) @item.object = item if item end #-------------------------------------------------------------------------- # ★ 行動主体の定義(追加定義) #-------------------------------------------------------------------------- def subject=(subject) @subject = subject if subject end end #============================================================================== # ■ Game_Actor #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # ★ パッシブスキルキャッシュの作成(アクター)(追加定義) #-------------------------------------------------------------------------- def make_passive_cache @note_cache ||= ["","","",""] ; @data_cache ||= [[],[],[],[]] @passive_cache ||= [[],[],[],[]] ; @passive_data ||= [] @passive_skills ||= [] @actor_cache ||= [] ; @state_cache ||= [] @equip_cache ||= [] ; @skill_cache ||= [] @add_feature_cache ||= [] ; @refresh_flag ||= [] end #-------------------------------------------------------------------------- # ★ バトラーのメモをセット(アクター)(追加定義) #-------------------------------------------------------------------------- def set_battler_note return if [@actor_id, @class_id, multi_class_obj] == @actor_cache @actor_cache = [@actor_id, @class_id, multi_class_obj].clone @note_cache[0] = self.actor.note + self.class.note + multi_class_note @refresh_flag = [] $game_party.refresh_flag = [] end #-------------------------------------------------------------------------- # ★ 装備のメモをセット(アクター)(追加定義) #-------------------------------------------------------------------------- def claer_equip_cache @equip_cache = [] end #-------------------------------------------------------------------------- # ★ 装備のメモをセット(アクター)(追加定義) #-------------------------------------------------------------------------- def set_equip_note return if equips_ids == @equip_cache @equip_cache = equips_ids.clone @note_cache[2] = equips_note @refresh_flag = [] $game_party.refresh_flag = [] end #-------------------------------------------------------------------------- # ★ 装備品オブジェクトのID配列取得(追加定義) #-------------------------------------------------------------------------- def equips_ids @equips.collect {|item| item.object && !item.object.broken? ? item.object.id : 0 } end #-------------------------------------------------------------------------- # ★ 装備品オブジェクトのメモ取得(追加定義) #-------------------------------------------------------------------------- def equips_note @equips.select{|item| item.object && !item.object.broken?}.collect{|item| item.object.note}.join end #-------------------------------------------------------------------------- # ★ スキルのメモをセット(アクター)(追加定義) #-------------------------------------------------------------------------- def set_skill_note return if setting_skills == @skill_cache add = setting_skills - @skill_cache remove = @skill_cache - setting_skills add.each{|id| @data_cache[3].push([id, $data_skills[id].note])} remove.each{|id| find = @data_cache[3].find_index{|block| block[0] == id} @data_cache[3].delete_at(find) if find } @skill_cache = setting_skills.clone @note_cache[3] = @data_cache[3].collect{|block| block[1]}.join set_passive_skills @refresh_flag = [] $game_party.refresh_flag = [] end #-------------------------------------------------------------------------- # ★ パッシブスキルを構築(追加定義) #-------------------------------------------------------------------------- def set_passive_skills passive_list = KURE.passive_skill_id(@note_cache[3]) (0..3).each {|index| next if @passive_cache[index] == passive_list[index] add = passive_list[index] - @passive_cache[index] remove = @passive_cache[index] - passive_list[index] case index when 0 ; add.each{|id| @passive_data.push([0, id, $data_weapons[id].features])} when 1 ; add.each{|id| @passive_data.push([1, id, $data_armors[id].features])} when 2 ; add.each{|id| @passive_data.push([2, id, $data_classes[id].features])} when 3 ; add.each{|id| @passive_data.push([3, id, $data_states[id].features])} end remove.each{|id| find = @passive_data.find_index{|block| block[0] == index && block[1] == id} @passive_data.delete_at(find) if find } @passive_cache[index] = passive_list[index].clone } end #-------------------------------------------------------------------------- # ★ パッシブスキルの取得(追加定義) #-------------------------------------------------------------------------- def passive_skills_feature return @passive_data.collect{|block| block[2]}.flatten end #-------------------------------------------------------------------------- # ★ 指定IDのスキルがパッシブ条件を満たすか(追加定義) #-------------------------------------------------------------------------- def passive_condition?(skill_id) return false unless passive_condition_e?(skill_id) return false unless passive_condition_w?(skill_id) return false unless passive_condition_a?(skill_id) return true end #-------------------------------------------------------------------------- # ★ 指定IDのスキルの発動装備タイプパッシブ条件(追加定義) #-------------------------------------------------------------------------- def passive_condition_e?(skill_id) data = $data_skills[skill_id].need_equip_passive return true if data == [] data.each{|id| return true if equips.compact.any? {|equip| equip.etype_id == id } } return false end #-------------------------------------------------------------------------- # ★ 指定IDのスキルがパッシブ条件を満たすか(追加定義) #-------------------------------------------------------------------------- def passive_condition_w?(skill_id) data = $data_skills[skill_id].need_weapon_passive return true if data == [] return true if data.include?(0) && weapons == [] $data_skills[skill_id].need_weapon_passive.each{|id| return true if wtype_equipped?(id) } return false end #-------------------------------------------------------------------------- # ★ 指定IDのスキルがパッシブ条件を満たすか(追加定義) #-------------------------------------------------------------------------- def passive_condition_a?(skill_id) data = $data_skills[skill_id].need_armor_passive return true if data == [] return true if data.include?(0) && armors == [] $data_skills[skill_id].need_armor_passive.each{|id| return true if armors.any? {|armor| armor.atype_id == id } } return false end #-------------------------------------------------------------------------- # ◎ 全ての特徴オブジェクトの配列取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_all_features :all_features unless $! def all_features k_integrate_before_all_features + passive_skills_feature.compact end #-------------------------------------------------------------------------- # ◎ スキルを覚える(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_learn_skill :learn_skill unless $! def learn_skill(skill_id) return if $data_skills[skill_id].unuseable_actor.include?(self.id) k_integrate_before_learn_skill(skill_id) set_passive_object end #-------------------------------------------------------------------------- # ◎ スキルを忘れる(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_forget_skill :forget_skill unless $! def forget_skill(skill_id) k_integrate_before_forget_skill(skill_id) set_passive_object end #-------------------------------------------------------------------------- # ◎ スキルの必要武器を装備しているか(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_skill_wtype_ok? :skill_wtype_ok? unless $! def skill_wtype_ok?(skill) case skill.need_dual when 1 ; return false if !dual_wield? when 2 ; return false if weapons.size <= 1 or !dual_wield? when 3 ; return false if !same_wtype? or !dual_wield? end skill.required_add_etype.each{|id| return false unless etype_equipped?(id)} skill.required_add_atype.each{|id| return false unless atype_equipped?(id)} skill.required_add_wtype.each{|id| return true if wtype_equipped?(id)} k_integrate_before_skill_wtype_ok?(skill) end #-------------------------------------------------------------------------- # ● 特定の装備タイプ(盾、鎧等)を装備しているか #-------------------------------------------------------------------------- def etype_equipped?(etype_id) equips.any? {|equip| equip && equip.etype_id == etype_id } end #-------------------------------------------------------------------------- # ● 特定の防具タイプ(一般防具、魔法防具)を装備しているか #-------------------------------------------------------------------------- def atype_equipped?(atype_id) armors.any? {|armor| armor && armor.atype_id == atype_id } end #-------------------------------------------------------------------------- # ● 特定のタイプの装備を装備しているか #-------------------------------------------------------------------------- def same_wtype? return false if weapons.size <= 1 return true if weapons[0].wtype_id == weapons[1].wtype_id return false end #-------------------------------------------------------------------------- # ● 装備の強制変更(再定義) #-------------------------------------------------------------------------- def force_change_equip(slot_id, item) @equips[slot_id].object = item release_unequippable_items(false) force_refresh end #-------------------------------------------------------------------------- # ★ 戦闘行動を追加(追加定義) #------------------------------------------------------------------------- def add_current_action(action) @actions.unshift(action) end #-------------------------------------------------------------------------- # ★ コマンド位置を一つ戻す(追加定義) #-------------------------------------------------------------------------- def reinput_command @actions.shift @action_input_index -= 1 end #-------------------------------------------------------------------------- # ★ アビリティポイントの追加（追加定義） #-------------------------------------------------------------------------- def add_ability_point(value) @ability_list ||= [] new_skills = [] ability_list.each{|data| next if skill_learn?($data_skills[data[0]]) @ability_list[data[0]] ||= 0 @ability_list[data[0]] += value * data[1] if @ability_list[data[0]] > 1000 learn_skill(data[0]) new_skills.push($data_skills[data[0]]) @ability_list[data[0]] = 0 end } display_new_skills(new_skills) end #-------------------------------------------------------------------------- # ★ アビリティポイントリストの呼び出し（追加定義） #-------------------------------------------------------------------------- def ability_point_list @ability_list ||= [] ; result = [] @ability_list.each_with_index{|data, index| next unless data result.push([index, data])} return result end #-------------------------------------------------------------------------- # ★ 特定IDのアビリティポイントの呼び出し（追加定義） #-------------------------------------------------------------------------- def call_ability_point(id) @ability_list ||= [] return @ability_list[id] ? @ability_list[id] : 0 end #-------------------------------------------------------------------------- # ★ 新規修得スキルの表示（追加定義） #-------------------------------------------------------------------------- def display_new_skills(new_skills) return if new_skills == [] new_skills.each{|skill| $game_message.add(sprintf(Vocab::Ability_New_skill, @name, skill.name))} end #-------------------------------------------------------------------------- # ◎ レベルアップ(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_level_up :level_up def level_up k_integrate_before_level_up after_level_up_process end #-------------------------------------------------------------------------- # ★ レベルアップ後の追加処理（追加定義） #-------------------------------------------------------------------------- def after_level_up_process #レベル補正 level_bonus_revise.each{|block| add_param(block[0], block[1])} end end #============================================================================== # ■ Game_Enemy #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # ★ パッシブスキルキャッシュの作成(エネミー)(追加定義) #-------------------------------------------------------------------------- def make_passive_cache @note_cache ||= ["" ,""] ; @data_cache ||= [[],[]] @enemy_cache ||= [] ; @state_cache ||= [] @add_feature_cache ||= [] ;@refresh_flag ||= [] end #-------------------------------------------------------------------------- # ★ バトラーのメモをセット(エネミー)(追加定義) #-------------------------------------------------------------------------- def set_battler_note return if [@enemy_id] == @enemy_cache @enemy_cache = [@enemy_id].clone @note_cache[0] = self.enemy.note @refresh_flag = [] end #-------------------------------------------------------------------------- # ◎ お金の取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_gold :gold unless $! def gold k_integrate_before_gold * gain_gold_rate end #-------------------------------------------------------------------------- # ◎ ドロップアイテム取得率の倍率を取得(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_drop_item_rate :drop_item_rate unless $! def drop_item_rate k_integrate_before_drop_item_rate * $game_party.party_drop_rate * gain_drop_rate end #-------------------------------------------------------------------------- # ◎ ドロップアイテムの配列作成(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_make_drop_items :make_drop_items unless $! def make_drop_items k_integrate_before_make_drop_items + make_cond_drop_items end #-------------------------------------------------------------------------- # ★ 条件ドロップアイテムの配列作成(追加定義) #-------------------------------------------------------------------------- def make_cond_drop_items drop_list = [] enemy.condition_drop_items.each{|block| case block[0] when 0 ; next unless @finish_cond[0].include?(block[1]) when 1 next if !@finish_cond[1] or !@finish_cond[2] next unless basic_element_list(@finish_cond[2], @finish_cond[1]).include?(block[1]) end drop_list.push(item_object(block[3],block[4])) } return drop_list end #-------------------------------------------------------------------------- # ★ スティールリストを呼び出し(追加定義) #-------------------------------------------------------------------------- def steal_list(id) enemy.steal_list.select{|block| block[0] == id} end #-------------------------------------------------------------------------- # ★ レベルを呼び出し(追加定義) #-------------------------------------------------------------------------- def level enemy.level end #-------------------------------------------------------------------------- # ★ IDを呼び出し(追加定義) #-------------------------------------------------------------------------- def id @enemy_id end #-------------------------------------------------------------------------- # ★ アビリティポイントの取得(追加定義) #-------------------------------------------------------------------------- def ability_exp enemy.ability_exp end end #============================================================================== # ■ BattleManager #============================================================================== class << BattleManager #-------------------------------------------------------------------------- # ◎ 獲得した経験値の表示(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_display_exp :display_exp def display_exp k_integrate_before_display_exp #アビリティポイント if $game_troop.ability_exp_total > 0 text_sp = sprintf(Vocab::ObtainAbilityP, $game_troop.ability_exp_total) $game_message.add('\.' + text_sp) end end #-------------------------------------------------------------------------- # ◎ 経験値の獲得とレベルアップの表示(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_gain_exp :gain_exp def gain_exp $game_party.all_members.each{|actor| actor.add_ability_point($game_troop.ability_exp_total)} k_integrate_before_gain_exp end #-------------------------------------------------------------------------- # ◎ 戦闘終了 result : 結果（0:勝利 1:逃走 2:敗北）(エイリアス再定義) #-------------------------------------------------------------------------- alias :k_integrate_before_battle_end :battle_end unless $! def battle_end(result) add_feature_process(result) $game_temp.first_invoke = false k_integrate_before_battle_end(result) end #-------------------------------------------------------------------------- # ★ 戦闘終了時の拡張特徴処理 result : 結果（0:勝利 1:逃走 2:敗北）(追加定義) #-------------------------------------------------------------------------- def add_feature_process(result) #戦闘後回復 party_heal = [0,0] $game_party.battle_members.each{|actor| next if actor.after_healing == [[0,0],[0,0]] actor.hp += (actor.mhp * (actor.after_healing[0][0].to_f / 100)).to_i actor.mp += (actor.mmp * (actor.after_healing[0][1].to_f / 100)).to_i party_heal[0] += actor.after_healing[1][0] party_heal[1] += actor.after_healing[1][1] } $game_party.battle_members.each{|actor| actor.hp += (actor.mhp * (party_heal[0].to_f / 100)).to_i actor.mp += (actor.mmp * (party_heal[1].to_f / 100)).to_i } end end