#=========================================================================== # ◆ A1 Scripts ◆ # スキル拡張（RGSS3） # # バージョン ： 2.02 (2012/01/26) # 作者 ： A1 # URL　　　　　： http://a1tktk.web.fc2.com/ #--------------------------------------------------------------------------- # 機能： # ・パッシブスキルを設定できます # ・コンボスキルを設定できます # ・スキルレベルを設定できます # ・装備習得スキルを設定できます # ・リスト非表示スキルを設定できます # ・二刀流を拡張 # ・スキル使用に関して様々な設定ができます #--------------------------------------------------------------------------- # 更新履歴　　 ：2012/01/24 Ver1.00 リリース # 2012/01/26 Ver2.00 設定できる項目色々追加 # 2012/01/26 Ver2.01 該当アイテムがない状態でアイテム使用での不具合を修正 # 2012/01/26 Ver2.02 ひっさつわざ対応 #--------------------------------------------------------------------------- # 設置場所 # A1バトル共通スクリプト以下 # (リザルトウィンドウ以下) # (ダメージポップアップ以下) # (装備拡張以下) # (サイドビューバトル以上) # # 必要スクリプト # A1バトル共通スクリプト #--------------------------------------------------------------------------- # 使い方 # ■ 設定項目 に設定します # # データベース「アクター」「敵キャラ」「武器」「防具」のメモ欄に記述します # # <スキルレベル skill_id,lv> # 初期習得スキルレベルを設定します # # 例：<スキルレベル 80,5> # <スキルレベル 81,5> # # 複数スキルを記述することも可能です # # データベース「スキル」「武器」「防具」「ステート」のメモ欄に記述します # # <パッシブ効果 効果,[数値,数値,数値,数値,...]> # パッシブ効果については後述 # # データベース「武器」「防具」「アイテム」のメモ欄に記述します # # <アイテム価値 value> # データベース「スキル」「計算式」に使用する # アイテム価値を設定します # # データベース「武器」「防具」のメモ欄に記述します # # <習得スキル skill_id,skill_id,skill_id...> # 装備することで（一時的に）習得するスキルを設定します # # 例：<習得スキル 80,81,82> # # データベース「スキル」のメモ欄に記述します # # <必要習得経験値 exp> # 装備スキルを恒久的に習得するために必要なスキル経験値を設定します # 設定なし、もしくは 0 に設定すると一時習得のみになります # # <習得条件 [skill_id,lv],[skill_id,lv],[skill_id,lv]...> # 習得する条件を設定します # # 例：<習得スキル [80,5],[81,5],[82,5]> # # 上記設定したスキルは、スキルID 80 81 82 の # スキルレベルが 5 になったら習得します # # <必要経験値 exp,exp,exp,exp,exp,exp,exp...> # スキルレベルアップに必要なスキル経験値を設定します # 設定なし、もしくは 0 に設定するとスキルレベルは上がりません # # 例：<必要経験値 10,20,30,40,50,60,70,80,90> # # 上記設定で、スキルレベル10まで上がります (累計必要スキル経験値：450) # # 例：<必要経験値 10,20,30,40> # # 上記設定で、スキルレベル5まで上がります (累計必要スキル経験値：100) # # <レベル倍率 rate,rate,rate,rate,...> # スキルレベルごとの倍率を設定します # 設定なしで100％の倍率になります # # 例：<レベル倍率 100,120,140,160,180> # # 上記設定で、スキルレベル1では100％、5では180％になります # 倍率はデータベース「スキル」の「計算式」で使用します # 計算式は下記「データベース「スキル」「計算式」の追加関数」参照のこと # # <リピート回数 num,num,num,num,num,.....> # リピートする回数を設定します # # 例：<リピート回数 1,2,3,4,5,6,7,8,9,10> # # 上記設定したスキルは、スキルレベル回数分、使用を繰り返します # また、MP/TPコストは1回分です # # # # 消費するMP/TPを設定します # 設定なしで、データベースに設定した消費量になります # # 例： # # 上記設定したスキルは、スキルレベル1で消費MP10 # スキルレベル10で消費MP28になります # # <使用後MP0> # <使用後TP0> # この設定をしたスキルは、使用後にMP/TPが 0 になります # # <使用レベル固定> # この設定をしたスキルは、スキルウィンドウでのレベル調整が不可になり # 常に習得している最大レベルを使用します # # <コンボスキル skill_id,skill_id,...> # スキル使用後にコンボウィンドウを開き、入力した矢印キーに対応したスキルを発動します # 設定できるスキル数は 4 までです # # 例：<コンボスキル 124,125,126> # # スキル使用後にコンボウィンドウが開かれ # コンボウィンドウが開いている間にキー入力することで設定したスキルが発動します # # 対応するキーは、設定した順に ↑・←・→・↓ となります # # <コンボ専用> # この設定をしたスキルは、コンボ専用スキルになり # バトル中に単体では発動できなくなります # # <リスト非表示> # この設定をしたスキルは、リスト非表示スキルになり # マップ画面、バトル画面関わらず表示されなくなります # # <使用条件ステート state_id,state_id,state_id,state_id,...> # 設定した全てのステートにかかっていないとスキルが使用できなくなります # # 例：<使用条件ステート 21,22> # # この設定をしたスキルは、ステートID 21 22 の両方にかかっていないと # 使用できません # # <使用後ステート付与 state_id,state_id,state_id,state_id,...> # スキル使用後、スキル使用者が設定した全てのステートにかかります # # 例：<使用後ステート 2,3> # # この設定をしたスキルは、スキル使用後に # ステートID 2 3 にかかります # # <使用後ステート解除 state_id,state_id,state_id,state_id,...> # スキル使用後、スキル使用者の設定した全てのステートを解除します # # <使用スキル skill_id,skill_id,skill_id,skill_id,...> # 他のスキルを使用します # # 例：<使用スキル 140,141,142,143,144,145> # # この設定をしたスキルは、スキルレベル1ではスキルID140のスキルを # スキルレベル5ではスキルID145のスキルを使用します # # <使用アイテム item_id,item_id,item_id,item_id,...> # スキル使用の際にアイテムを消費します # item_idに -1 を設定すると、スキル選択後にアイテム選択ウィンドウを開きます # # 例：<使用アイテム 1,2,3,4> # # この設定をしたスキルは、スキルレベル1ではアイテムID1のアイテムを # スキルレベル4ではアイテムID4のアイテムを消費します # # アイテムがHP/MP回復アイテムの場合 # 効果をレベル倍率分増加して使用します # # 例：<使用アイテム -1> # # この設定をしたスキルは、スキルレベルに関わらず # アイテムウィンドウが開き、選択したアイテムを使用します # # <アイテム選択 kind> # 使用アイテムのアイテム選択の際に、表示するアイテム種別を指定します # # kind：武器 所持している武器を表示します # kind：防具 所持しているアイテムを表示します # kind：アイテム 所持しているアイテムの中で、使用できないアイテムを表示します # # この アイテム選択 を設定しない場合、使用できるアイテムが表示されます # # <使用ゴールド gold,gold,gold,gold,gold,....> # スキル使用の際にゴールドを消費します # # 例：<使用ゴールド 100,200,300,400,500,600,700,800,900,1000> # # この設定をしたスキルは、スキルレベル1では100ゴールドを # スキルレベル10では1000ゴールド消費します # # <追加発動可> # パッシブ効果「追加発動」は通常攻撃のみ対象ですが # この設定をしたスキルも「追加発動」の対象になります # # <現在レベル倍率使用> # この設定をしたスキルは使用スキルレベルを下げたとしても # 使用できる最大レベルの倍率を使用します #--------------------------------------------------------------------------- # ■ 設定項目 に説明のないパッシブ効果 # # <パッシブ効果 スキル変化,[rate,rate,rate,rate...]> # 通常攻撃時、スキルレベルに応じた rate ％で設定したスキルになります # # 例：<パッシブ効果 スキル変化,[5,10,15,20,25,30,35,40,45,50]> # # この設定をしたスキルは、通常攻撃時に # スキルレベル1では5％、スキルレベル10では50％の確率で # 設定したスキルに変化します # # <パッシブ効果 二刀流> # 二刀流が可能になります # # <パッシブ効果 割引,[rate,rate,rate,rate...]> # ショップでの購入が rate ％割引されます # # <パッシブ効果 割増,[rate,rate,rate,rate...]> # ショップでの売却が rate ％割増されます # # <パッシブ効果 追加発動[skill_id, skill_level],[rate,rate,rate,rate...]> # skill_id のスキルを skill_level で、rate ％の確率で # 通常攻撃後に発動します # # 例：<パッシブ効果 追加発動[140, 3],[50]> # # この設定をしたスキルは、通常攻撃後に # スキルレベルに関わらず 50% の確率で スキルID140のスキルを # スキルレベル3で発動します #--------------------------------------------------------------------------- # データベース「スキル」「計算式」の追加関数 # # rate(skill_id) # # 「レベル倍率」で設定した倍率を取得します # skill_id を省略すると、使用したスキルの倍率を取得します # # 例：(a.atk * 4) * a.rate - b.def * 2 # # 使用者の攻撃力 * 4 に、さらに設定した倍率をかけ # 対象の防御力 * 2 を引く、と言う計算式になります # # 例：(a.atk * 4) * a.rate - (b.def * 2) * b.rate(140) # # この場合、ID140のスキルが防御スキルだとすると # 防御力に防御スキルの倍率をかけることになります # # s_lv(skill_id) # # スキルレベルを取得します # skill_id を省略すると、使用したスキルのスキルレベルを取得します # # 例：a.atk * (8 + a.mp / 10) + 250 + a.s_lv * 150 # # item_value # # アイテムのアイテム価値を取得します # item を省略すると、スキルで使用したアイテムのアイテム価値を取得します # # またデータベース「武器」「防具」「アイテム」に # 「アイテム価値」の設定をしていないアイテムは 0 が返されます # # 例：(a.atk * 4) * a.item_value - b.def * 2 # # gold # スキルで使用した金額を取得します # # 例：(a.atk * 4) * a.gold - b.def * 2 # # またデータベース「スキル」に # 「使用ゴールド」の設定をしていないスキルは 0 が返されます #============================================================================== $imported ||= {} if $imported["A1_BattleCommonScript"] $imported["A1_PassiveSkill"] = true old_common_script("スキル拡張", "4.50") if common_version < 4.50 #============================================================================== # ■ 設定項目 #============================================================================== module A1_System::PassiveSkillConfig #-------------------------------------------------------------------------- # ○ コンボスキル入力時間(フレーム) #-------------------------------------------------------------------------- COMBO_INPUT_COUNT = 30 #-------------------------------------------------------------------------- # ○ スキルレベルを使用するか？ # ※ false にしても、装備スキルは適用されます #-------------------------------------------------------------------------- USE_SKILL_LEVEL = true #-------------------------------------------------------------------------- # ○ スキル使用でのスキル経験値アップ # ※ true にしても、装備スキルの経験値は加算されません #-------------------------------------------------------------------------- USE_NUM = true #-------------------------------------------------------------------------- # ○ スキル経験値獲得でのスキル経験値アップ # ※ false にしても 装備スキルの経験値は加算されます #-------------------------------------------------------------------------- SKILL_EXP = false #-------------------------------------------------------------------------- # ○ 獲得したスキル経験値をリザルトウィンドウに表示するか？ #-------------------------------------------------------------------------- DRAW_RESULT = true #-------------------------------------------------------------------------- # ○ スキル経験値の名前 #-------------------------------------------------------------------------- SKILL_EXP_NAME = "AP" #-------------------------------------------------------------------------- # ○ スキル経験値未設定の敵が持つスキル経験値 # 設定はデータベース「敵キャラ」のメモ欄に記述 # # 例：<スキル経験値 4> #-------------------------------------------------------------------------- DEFAULT_AP = 2 #-------------------------------------------------------------------------- # ○ 右手/左手修練を使用する？ (装備拡張スクリプト導入時) # 使用する際はデータベース「スキル」のメモ欄に記述 # #　　例：<パッシブ効果 右手修練,[40.50,60,70,80]> ※スキルレベル使用時 #　　例：<パッシブ効果 右手修練,[80]> ※スキルレベル非使用時 #-------------------------------------------------------------------------- USE_HAND_MASTARY = true #-------------------------------------------------------------------------- # ○ 右手/左手修練未修得時の保証攻撃レート (装備拡張スクリプト導入時) # 0.3 で30％です #-------------------------------------------------------------------------- MIN_HAND_MASTARY = 0.3 #-------------------------------------------------------------------------- # ○ 利き腕に加える攻撃レート (装備拡張スクリプト導入時) # 0.2 で20％です # 上記例と合わせると、右利きの場合右手修練Lv5時に100％になります #-------------------------------------------------------------------------- ADD_HAND_MASTARY = 0.2 #-------------------------------------------------------------------------- # ○ データベース「スキル」のメモ欄に記述するパラメータ # # 例：<パッシブ効果 最大HP,[100,200,300,400,500,600,700,800,900,1000]> ※スキルレベル使用時 # 例：<パッシブ効果 最大HP,[1000]> ※スキルレベル非使用時 # # データベース「用語」の「武器タイプ」の名前を頭につけると # 該当する武器タイプを装備した時のみ有効になります # # 例：<パッシブ効果 斧攻撃力,[4,8,12,16,20,24,28,32,36,40]> ※スキルレベル使用時 # 例：<パッシブ効果 斧攻撃力,[40]> ※スキルレベル非使用時 #-------------------------------------------------------------------------- PARAMS_PASSIVE = { 0 => "最大HP", 1 => "最大MP", 2 => "攻撃力", 3 => "防御力", 4 => "魔法力", 5 => "魔法防御", 6 => "敏捷性", 7 => "運", } #-------------------------------------------------------------------------- # ○ データベース「スキル」のメモ欄に記述するパラメータ # # 例：<パッシブ効果 回避率,[3,6,9,12,15,18,21,24,27,30]> ※スキルレベル使用時 # 例：<パッシブ効果 回避率,[30]> ※スキルレベル非使用時 # # 元の値に加算しますので、上記例ならスキルLv10で回避率+30％となります #-------------------------------------------------------------------------- XPARAMS_PASSIVE = { 0 => "命中率", 1 => "回避率", 2 => "会心率", 3 => "会心回避率", 4 => "魔法回避率", 5 => "魔法反射率", 6 => "反撃率", 7 => "HP再生率", 8 => "MP再生率", 9 => "TP再生率", } #-------------------------------------------------------------------------- # ○ データベース「スキル」のメモ欄に記述するパラメータ # # 例：<パッシブ効果 経験獲得率,[10,20,30,40,50,60,70,80,90,100]> ※スキルレベル使用時 # 例：<パッシブ効果 経験獲得率,[100]> ※スキルレベル非使用時 # # 元の値に加算しますので、上記例ならスキルLv10で経験獲得率+100％となります #-------------------------------------------------------------------------- SPPARAMS_PASSIVE = { 0 => "狙われ率", 1 => "防御効果率", 2 => "回復効果率", 3 => "薬の知識", 4 => "MP消費率", 5 => "TPチャージ率", 6 => "物理ダメージ率", 7 => "魔法ダメージ率", 8 => "床ダメージ率", 9 => "経験獲得率", } end #============================================================================== # ■ RPG::BaseItem #============================================================================== class RPG::BaseItem #-------------------------------------------------------------------------- # ○ スキルレベル #-------------------------------------------------------------------------- def skills_level @skills_level ||= $a1_common.note_data_hash(self.note, "スキルレベル", {}) return @skills_level end #-------------------------------------------------------------------------- # ○ パッシブ効果 #-------------------------------------------------------------------------- def passive_effect @passive_effect ||= $a1_common.note_data_hash(self.note, "パッシブ効果", [1]) return @passive_effect end #-------------------------------------------------------------------------- # ○ パッシブスキル？ #-------------------------------------------------------------------------- def passive? !passive_effect.empty? end #-------------------------------------------------------------------------- # ○ アイテム価値 #-------------------------------------------------------------------------- def item_value @item_value ||= $a1_common.note_data_one_value(self.note, "アイテム価値", 1) return @item_value end end #============================================================================== # ■ RPG::EquipItem #============================================================================== class RPG::EquipItem < RPG::BaseItem #-------------------------------------------------------------------------- # ○ スキルレベル #-------------------------------------------------------------------------- def learn_skills @learn_skills ||= $a1_common.note_data_array_value(self.note, "習得スキル", []) return @learn_skills end end #============================================================================== # ■ RPG::UsableItem #============================================================================== class RPG::UsableItem < RPG::BaseItem #-------------------------------------------------------------------------- # ○ 習得条件 #-------------------------------------------------------------------------- def learn_condition @learn_condition ||= $a1_common.note_data_array_value(self.note, "習得条件", []) return @learn_condition end #-------------------------------------------------------------------------- # ○ 必要習得経験値 #-------------------------------------------------------------------------- def need_learn_exp @need_learn_exp ||= $a1_common.note_data_one_value(self.note, "必要習得経験値", 0) return @need_learn_exp end #-------------------------------------------------------------------------- # ○ 必要経験値 #-------------------------------------------------------------------------- def need_exp @need_exp ||= $a1_common.note_data_array_value(self.note, "必要経験値", []) return @need_exp end #-------------------------------------------------------------------------- # ○ レベル倍率 #-------------------------------------------------------------------------- def level_rate @level_rate ||= $a1_common.note_data_array_value(self.note, "レベル倍率", [100]) return @level_rate end #-------------------------------------------------------------------------- # ○ リピート回数 #-------------------------------------------------------------------------- def repeat_num @repeat_num ||= $a1_common.note_data_array_value(self.note, "リピート回数", [1]) return @repeat_num end #-------------------------------------------------------------------------- # ○ 使用スキル #-------------------------------------------------------------------------- def level_use_skill @level_use_skill ||= $a1_common.note_data_array_value(self.note, "使用スキル", []) return @level_use_skill end #-------------------------------------------------------------------------- # ○ 使用アイテム #-------------------------------------------------------------------------- def level_use_item @level_use_item ||= $a1_common.note_data_array_value(self.note, "使用アイテム", []) return @level_use_item end #-------------------------------------------------------------------------- # ○ 使用ゴールド #-------------------------------------------------------------------------- def level_use_gold @level_use_gold ||= $a1_common.note_data_array_value(self.note, "使用ゴールド", []) return @level_use_gold end #-------------------------------------------------------------------------- # ○ MPコスト #-------------------------------------------------------------------------- def level_mp_cost @level_mp_cost ||= $a1_common.note_data_array_value(self.note, "MPコスト", [@mp_cost]) return @level_mp_cost end #-------------------------------------------------------------------------- # ○ TPコスト #-------------------------------------------------------------------------- def level_tp_cost @level_tp_cost ||= $a1_common.note_data_array_value(self.note, "TPコスト", [@tp_cost]) return @level_tp_cost end #-------------------------------------------------------------------------- # ○ 使用後MP0 #-------------------------------------------------------------------------- def use_after_mp_zero @use_after_mp_zero = $a1_common.note_data(self.note, "使用後MP0") if @use_after_mp_zero == nil return @use_after_mp_zero end #-------------------------------------------------------------------------- # ○ 使用後TP0 #-------------------------------------------------------------------------- def use_after_tp_zero @use_after_tp_zero = $a1_common.note_data(self.note, "使用後TP0") if @use_after_tp_zero == nil return @use_after_tp_zero end #-------------------------------------------------------------------------- # ○ 使用レベル固定 #-------------------------------------------------------------------------- def fix_use_level @fix_use_level = $a1_common.note_data(self.note, "使用レベル固定") if @fix_use_level == nil return @fix_use_level end #-------------------------------------------------------------------------- # ○ コンボスキル #-------------------------------------------------------------------------- def combo_skill @combo_skill ||= $a1_common.note_data_array_value(self.note, "コンボスキル", []) return @combo_skill end #-------------------------------------------------------------------------- # ○ コンボ専用 #-------------------------------------------------------------------------- def combo_only @combo_only = $a1_common.note_data(self.note, "コンボ専用") if @combo_only == nil return @combo_only end #-------------------------------------------------------------------------- # ○ リスト非表示 #-------------------------------------------------------------------------- def hide_skill @hide_skill = $a1_common.note_data(self.note, "リスト非表示") if @hide_skill == nil return @hide_skill end #-------------------------------------------------------------------------- # ○ 追加発動可 #-------------------------------------------------------------------------- def add_skill_ok @add_skill_ok = $a1_common.note_data(self.note, "追加発動可") if @add_skill_ok == nil return @add_skill_ok end #-------------------------------------------------------------------------- # ○ 現在レベル倍率使用 #-------------------------------------------------------------------------- def use_now_level_rate @use_now_level_rate = $a1_common.note_data(self.note, "現在レベル倍率使用") if @use_now_level_rate == nil return @use_now_level_rate end #-------------------------------------------------------------------------- # ○ アイテム選択 #-------------------------------------------------------------------------- def item_selection @item_selection ||= $a1_common.note_data_one(self.note, "アイテム選択", "") return @item_selection end #-------------------------------------------------------------------------- # ○ 使用条件ステート #-------------------------------------------------------------------------- def use_condition_state @use_condition_state ||= $a1_common.note_data_array_value(self.note, "使用条件ステート", []) return @use_condition_state end #-------------------------------------------------------------------------- # ○ 使用後ステート付与 #-------------------------------------------------------------------------- def use_after_add_state @use_after_add_state ||= $a1_common.note_data_array_value(self.note, "使用後ステート付与", []) return @use_after_add_state end #-------------------------------------------------------------------------- # ○ 使用後ステート解除 #-------------------------------------------------------------------------- def use_after_remove_state @use_after_remove_state ||= $a1_common.note_data_array_value(self.note, "使用後ステート解除", []) return @use_after_remove_state end end #============================================================================== # ■ RPG::Enemy #============================================================================== class RPG::Enemy < RPG::BaseItem #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- DEFAULT_AP = A1_System::PassiveSkillConfig::DEFAULT_AP #-------------------------------------------------------------------------- # ○ スキル経験値 #-------------------------------------------------------------------------- def skill_exp @skill_exp ||= $a1_common.note_data_one_value(self.note, "スキル経験値", DEFAULT_AP) return @skill_exp end end #============================================================================== # ■ DataManager #------------------------------------------------------------------------------ # 　データベースとゲームオブジェクトを管理するモジュールです。ゲームで使用する # ほぼ全てのグローバル変数はこのモジュールで初期化されます。 #============================================================================== module DataManager #-------------------------------------------------------------------------- # ○ エイリアス用特異メソッド #-------------------------------------------------------------------------- class << self alias :a1_passive_skill_dm_create_game_objects :create_game_objects end #-------------------------------------------------------------------------- # ☆ 各種ゲームオブジェクトの作成 #-------------------------------------------------------------------------- def self.create_game_objects a1_passive_skill_dm_create_game_objects $game_skill_tree = Game_SkillTree.new end end #============================================================================== # ■ Game_SkillTree #============================================================================== class Game_SkillTree #-------------------------------------------------------------------------- # ○ オブジェクト初期化 #-------------------------------------------------------------------------- def initialize @condition_skill = {} $data_skills.compact.each {|skill| search_tree(skill) } end #-------------------------------------------------------------------------- # ○ スキルツリー検索 #-------------------------------------------------------------------------- def search_tree(skill) learn_condition = skill.learn_condition return if learn_condition.empty? learn_condition.each {|data| setup_condition_skill(data, skill.id) } end #-------------------------------------------------------------------------- # ○ 習得条件になるスキルを設定 #-------------------------------------------------------------------------- def setup_condition_skill(data, skill_id) @condition_skill[data[0]] ||= [] @condition_skill[data[0]].push(skill_id) end #-------------------------------------------------------------------------- # ○ 習得条件になるスキルを取得 #-------------------------------------------------------------------------- def condition_skill(skill_id) @condition_skill[skill_id] ||= [] return @condition_skill[skill_id] end end #============================================================================== # ■ Game_Enemy #------------------------------------------------------------------------------ # 　敵キャラを扱うクラスです。このクラスは Game_Troop クラス（$game_troop）の # 内部で使用されます。 #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # ○ スキル経験値の取得 #-------------------------------------------------------------------------- def skill_exp enemy.skill_exp end end #============================================================================== # ■ Game_Troop #------------------------------------------------------------------------------ # 　敵グループおよび戦闘に関するデータを扱うクラスです。バトルイベントの処理も # 行います。このクラスのインスタンスは $game_troop で参照されます。 #============================================================================== class Game_Troop < Game_Unit #-------------------------------------------------------------------------- # ○ スキル経験値の合計計算 #-------------------------------------------------------------------------- def skill_exp_total dead_members.inject(0) {|r, enemy| r += enemy.skill_exp } end end #============================================================================== # ■ Window_ShopBuy #------------------------------------------------------------------------------ # 　ショップ画面で、購入できる商品の一覧を表示するウィンドウです。 #============================================================================== class Window_ShopBuy < Window_Selectable #-------------------------------------------------------------------------- # ☆ 商品の値段を取得 #-------------------------------------------------------------------------- alias a1_passive_skill_wsb_price price def price(item) (a1_passive_skill_wsb_price(item) * (1 - $game_party.max_value_passive("割引") / 100.0 )).round.to_i end end #============================================================================== # ■ Scene_Shop #------------------------------------------------------------------------------ # 　ショップ画面の処理を行うクラスです。 #============================================================================== class Scene_Shop < Scene_MenuBase #-------------------------------------------------------------------------- # ☆ 売値の取得 #-------------------------------------------------------------------------- alias a1_passive_skill_ss_selling_price selling_price def selling_price (a1_passive_skill_ss_selling_price * (1 + $game_party.max_value_passive("割増") / 100.0 )).round.to_i end end #============================================================================== # ■ Game_Party #------------------------------------------------------------------------------ # 　パーティを扱うクラスです。所持金やアイテムなどの情報が含まれます。このクラ # スのインスタンスは $game_party で参照されます。 #============================================================================== class Game_Party < Game_Unit #-------------------------------------------------------------------------- # ○ 全メンバーからパッシブスキルの最大値を取得する #-------------------------------------------------------------------------- def max_value_passive(passive) $game_party.all_members.inject([]) {|r, actor| r += [actor.max_passive_value(actor.learnd_passive[passive])] }.max end end #============================================================================== # ■ Window_BattleItem #------------------------------------------------------------------------------ # 　バトル画面で、使用するアイテムを選択するウィンドウです。 #============================================================================== class Window_BattleItem < Window_ItemList #-------------------------------------------------------------------------- # ☆ アイテムをリストに含めるかどうか #-------------------------------------------------------------------------- alias a1_passive_skill_wbi_include? include? def include?(item) return item.is_a?(RPG::Weapon) if @item_kind == "武器" return item.is_a?(RPG::Armor) if @item_kind == "防具" return item.is_a?(RPG::Item) && !$game_party.usable?(item) if @item_kind == "アイテム" a1_passive_skill_wbi_include?(item) end #-------------------------------------------------------------------------- # ☆ アイテムを許可状態で表示するかどうか #-------------------------------------------------------------------------- alias a1_passive_skill_wbi_enable? enable? def enable?(item) return a1_passive_skill_wbi_enable?(item) unless @item_kind && !@item_kind.empty? return @actor.calc_need_item_num(@skill) <= $game_party.item_number(item) end #-------------------------------------------------------------------------- # ○ スキルの設定 #-------------------------------------------------------------------------- def skill=(skill) @skill = skill end #-------------------------------------------------------------------------- # ○ アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) @actor = actor end #-------------------------------------------------------------------------- # ○ 表示するアイテム種別 #-------------------------------------------------------------------------- def item_kind=(kind) @item_kind = kind end #-------------------------------------------------------------------------- # ○ 表示するアイテム種別の取得 #-------------------------------------------------------------------------- def item_kind @item_kind end end #============================================================================== # ■ Scene_Battle #------------------------------------------------------------------------------ # 　バトル画面の処理を行うクラスです。 #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- USE_NUM = A1_System::PassiveSkillConfig::USE_NUM SKILL_EXP = A1_System::PassiveSkillConfig::SKILL_EXP #-------------------------------------------------------------------------- # ☆ 全ウィンドウの作成 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_create_all_windows create_all_windows def create_all_windows a1_passive_skill_sb_create_all_windows create_combo_window end #-------------------------------------------------------------------------- # ○ バトルマネージャメソッドの定義 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_define_battle_manager_method define_battle_manager_method def define_battle_manager_method a1_passive_skill_sb_define_battle_manager_method BattleManager.define_method(method(:open_item_window), :open_item_window) end #-------------------------------------------------------------------------- # ○ コンボウィンドウの作成 #-------------------------------------------------------------------------- def create_combo_window @combo_window = Window_Combo.new @combo_window.define_method(method(:next_combo), :next_combo) end #-------------------------------------------------------------------------- # ○ アイテムウィンドウを開く #-------------------------------------------------------------------------- def open_item_window(item_kind, actor, skill) @skill_window.hide @item_window.item_kind = item_kind @item_window.actor = actor @item_window.skill = skill @item_window.refresh @item_window.show.activate wait_for_select_item_window return @item_window.item ? @item_window.item.id : nil end #-------------------------------------------------------------------------- # ☆ スキル［決定］ #-------------------------------------------------------------------------- alias a1_passive_skill_sb_on_skill_ok on_skill_ok def on_skill_ok BattleManager.actor.input.select_skill(true) a1_passive_skill_sb_on_skill_ok return unless @item_window.item_kind && !@item_window.item_kind.empty? @item_window.item_kind = nil @skill_window.refresh @skill_window.show.activate end #-------------------------------------------------------------------------- # ☆ 次のコマンド入力へ #-------------------------------------------------------------------------- alias a1_passive_skill_sb_next_command next_command def next_command return if @item_window.item_kind && !@item_window.item_kind.empty? a1_passive_skill_sb_next_command end #-------------------------------------------------------------------------- # ☆ アクター選択の開始 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_select_actor_selection select_actor_selection def select_actor_selection return if @item_window.item_kind && !@item_window.item_kind.empty? a1_passive_skill_sb_select_actor_selection end #-------------------------------------------------------------------------- # ☆ 敵キャラ選択の開始 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_select_enemy_selection select_enemy_selection def select_enemy_selection return if @item_window.item_kind && !@item_window.item_kind.empty? a1_passive_skill_sb_select_enemy_selection end #-------------------------------------------------------------------------- # ☆ アイテム［決定］ #-------------------------------------------------------------------------- alias a1_passive_skill_sb_on_item_ok on_item_ok def on_item_ok return a1_passive_skill_sb_on_item_ok unless @item_window.item_kind && !@item_window.item_kind.empty? @item_window.hide @item_window.item_kind = nil end #-------------------------------------------------------------------------- # ☆ アイテム［キャンセル］ #-------------------------------------------------------------------------- alias a1_passive_skill_sb_on_item_cancel on_item_cancel def on_item_cancel return a1_passive_skill_sb_on_item_cancel unless @item_window.item_kind && !@item_window.item_kind.empty? @item_window.hide end #-------------------------------------------------------------------------- # ○ アイテムウィンドウ選択中のウェイト #-------------------------------------------------------------------------- def wait_for_select_item_window update_basic while @item_window.visible end #-------------------------------------------------------------------------- # ○ 戦闘行動の実行の前処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_prev_execute_action prev_execute_action def prev_execute_action a1_passive_skill_sb_prev_execute_action @original_action_item = @subject.current_action.item end #-------------------------------------------------------------------------- # ○ 戦闘行動の実行の後処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_post_execute_action post_execute_action def post_execute_action a1_passive_skill_sb_post_execute_action @subject.current_action.set_skill(@original_action_item.id) if @original_action_item.is_a?(RPG::Skill) end #-------------------------------------------------------------------------- # ○ スキル／アイテムの使用の前処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_prev_use_item prev_use_item def prev_use_item a1_passive_skill_sb_prev_use_item setup_skill_change(@subject.current_action.item) setup_use_other_skill(@subject.current_action.item) setup_use_item_skill_effect(@subject.current_action.item) end #-------------------------------------------------------------------------- # ○ アイテムを使うスキルのセットアップ #-------------------------------------------------------------------------- def setup_use_item_skill_effect(skill) return unless skill.is_a?(RPG::Skill) item = @subject.current_action.use_item return unless item.is_a?(RPG::Item) @subject.current_action.item.effects = item.effects @subject.current_action.item.damage = item.damage @subject.current_action.item.animation_id = item.animation_id @subject.current_action.item.hit_type = item.hit_type @subject.current_action.item.success_rate = item.success_rate end #-------------------------------------------------------------------------- # ○ 他のスキルを使う場合のセットアップ #-------------------------------------------------------------------------- def setup_use_other_skill(skill) return unless skill.is_a?(RPG::Skill) level_use_skill = skill.level_use_skill return if level_use_skill.empty? new_skill = @subject.level_use_skill(skill) return unless new_skill && @subject.skill_conditions_met?($data_skills[new_skill]) @subject.current_action.set_skill(new_skill) if new_skill end #-------------------------------------------------------------------------- # ○ 通常攻撃がスキルに変化する場合のセットアップ #-------------------------------------------------------------------------- def setup_skill_change(item) return if !item.is_a?(RPG::Skill) || item.id != @subject.attack_skill_id passive = @subject.learnd_passive["スキル変化"] return unless passive new_skill = passive.keys.select {|id| skill_change_condition(passive[id], id) }[0] @subject.current_action.set_skill(new_skill) if new_skill end #-------------------------------------------------------------------------- # ○ 通常攻撃がスキルに変化する条件のチェック #-------------------------------------------------------------------------- def skill_change_condition(passive, skill_id) return false if !@subject.skill_conditions_met?($data_skills[skill_id]) rate = @subject.passive_value(passive, skill_id) return rand(100) < rate end #-------------------------------------------------------------------------- # ☆ スキル／アイテムの使用の後処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_post_use_item post_use_item def post_use_item a1_passive_skill_sb_post_use_item item = @subject.current_action.item skill_exp_gain_for_use(@subject, item) if @subject.actor? && item.is_a?(RPG::Skill) use_after_effect(item) refresh_status use_after_next_skill(item) end #-------------------------------------------------------------------------- # ○ スキル／アイテムの使用後の使用者への効果 #-------------------------------------------------------------------------- def use_after_effect(item) @subject.mp = 0 if item.use_after_mp_zero @subject.tp = 0 if item.use_after_tp_zero item.use_after_add_state.each {|state_id| @subject.add_state(state_id) } item.use_after_remove_state.each {|state_id| @subject.remove_state(state_id) } end #-------------------------------------------------------------------------- # ○ スキル／アイテムの使用後の追加発動スキル #-------------------------------------------------------------------------- def use_after_next_skill(item) return if @subject.hp <= 0 search_add_proc_skill(@subject.learnd_passive, item) combo = @subject.current_action.item.combo_skill return if combo.empty? || @subject.current_action.targets.all? {|target| target.hp <= 0 } return open_combo_window if @subject.actor? next_combo($data_skills[combo.compact[0]]) end #-------------------------------------------------------------------------- # ○ 追加発動スキルの検索 #-------------------------------------------------------------------------- def search_add_proc_skill(passive, item) return false if !item.is_a?(RPG::Skill) || !add_skill_ok?(item) proc_skill = [] passive.each_pair {|kind, vlaue| proc_skill = proc_add_skill($1.to_i, $2.to_i, vlaue) if kind =~ /追加発動\[(\d+)[,]?(\d+)?\]/ } return if proc_skill.empty? backup_current_action = @subject.current_action.item.clone proc_skill.each {|skill_data| proc_next_skill(skill_data[0], skill_data[1]) } @subject.current_action.set_skill(backup_current_action.id) end #-------------------------------------------------------------------------- # ○ 通常攻撃？ #-------------------------------------------------------------------------- def add_skill_ok?(item) item.id == @subject.attack_skill_id || item.add_skill_ok end #-------------------------------------------------------------------------- # ○ 追加発動スキルの発動 #-------------------------------------------------------------------------- def proc_add_skill(skill_id, skill_level, rates, ret = []) rates.each_pair {|key, rate| ret.push([skill_id, skill_level]) if add_skill_proc?(key, rate) } return ret end #-------------------------------------------------------------------------- # ○ 追加発動スキルが発動？ #-------------------------------------------------------------------------- def add_skill_proc?(skill_id, passive) return rand(100) < passive[0] if skill_id.is_a?(Array) return rand(100) < @subject.passive_value(passive, skill_id) end #-------------------------------------------------------------------------- # ○ 追加発動スキルを実行 #-------------------------------------------------------------------------- def proc_next_skill(skill_id, skill_level) return if @subject.current_action.targets.all? {|target| target.hp <= 0 } backup_use_skill_level = @subject.use_skill_level(skill_id) @subject.set_use_skill_level(skill_id, skill_level, "FIX") next_combo($data_skills[skill_id]) if @subject.skill_conditions_met?($data_skills[skill_id]) @subject.set_use_skill_level(skill_id, backup_use_skill_level, "FIX") @subject.clear_force_use_level end #-------------------------------------------------------------------------- # ○ コンボウィンドウのオープン #-------------------------------------------------------------------------- def open_combo_window @combo_window.setup_data(@subject, @subject.current_action.item) @combo_window.open unless @combo_window.item.empty? wait_for_input_combo end #-------------------------------------------------------------------------- # ○ コンボ入力待ち #-------------------------------------------------------------------------- def wait_for_input_combo update_basic while @combo_window.visible end #-------------------------------------------------------------------------- # ○ コンボスキルの実行 #-------------------------------------------------------------------------- def next_combo(skill) return unless @subject.skill_conditions_met?(skill) @subject.current_action.set_skill(skill.id) use_item end #-------------------------------------------------------------------------- # ☆ スキル／アイテムの使用 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_use_item use_item def use_item @subject.repeat_num = -1 item = @subject.current_action.item @repeat_num = item.is_a?(RPG::Skill) ? @subject.skill_repeat_num(item) : item_repeat_num(item) a1_passive_skill_sb_use_item while item_repeat @repeat_num = 0 @subject.repeat_num = 0 end #-------------------------------------------------------------------------- # ○ アイテムの繰り返し回数取得 #-------------------------------------------------------------------------- def item_repeat_num(item) return 1 end #-------------------------------------------------------------------------- # ○ スキル/アイテムの繰り返し実行 #-------------------------------------------------------------------------- def item_repeat @subject.repeat_num += 1 return false if @subject.current_action.targets && @subject.current_action.targets.all? {|target| target.hp <= 0 } return @subject.repeat_num < @repeat_num end #-------------------------------------------------------------------------- # ○ 敵が持つスキル経験値の合計を取得 #-------------------------------------------------------------------------- def skill_exp_total $game_troop.skill_exp_total end #-------------------------------------------------------------------------- # ○ 勝利の処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_process_victory process_victory def process_victory $game_party.all_members.each {|member| skill_exp_gain_member(member) } a1_passive_skill_sb_process_victory end #-------------------------------------------------------------------------- # ○ 勝利後のスキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_member(member) member.skills.each {|skill| skill_exp_gain_for_victory(member, skill) } member.equip_skills.each {|skill| equip_skill_exp_gain_for_victory(member, skill) } end #-------------------------------------------------------------------------- # ○ リザルトウィンドウに新スキルを追加する #-------------------------------------------------------------------------- def add_result_new_skill(actor, skill, new_skills) end #-------------------------------------------------------------------------- # ○ リザルトウィンドウに習得した装備スキルを追加する #-------------------------------------------------------------------------- def add_result_learn_skill(actor, skill, new_skills) end #-------------------------------------------------------------------------- # ○ 戦闘終了時のメンバー初期化 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_init_member_battle_end init_member_battle_end def init_member_battle_end(member) a1_passive_skill_sb_init_member_battle_end(member) member.clear_levelup_skills member.clear_equip_learn_skills end #-------------------------------------------------------------------------- # ○ 勝利後の装備スキル経験値アップ #-------------------------------------------------------------------------- def equip_skill_exp_gain_for_victory(actor, skill) actor.skill_gain_exp(skill, skill_exp_total) add_result_learn_skill(actor, skill) if actor.skills.include?(skill) end #============================================================================== # ■ スキルレベル制使用時の処理 #============================================================================== if A1_System::PassiveSkillConfig::USE_SKILL_LEVEL #-------------------------------------------------------------------------- # ○ スキル使用後のスキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_for_use(actor, item) return unless USE_NUM last_skill = actor.skills actor.skill_exp_gain_with_all_passive(item) new_skills = actor.skills - last_skill new_skills.each {|skill| @log_window.display_new_skill(actor, skill) } end #-------------------------------------------------------------------------- # ○ 勝利後のスキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_for_victory(actor, skill) return unless SKILL_EXP last_skill = actor.skills actor.skill_gain_exp(skill, skill_exp_total) new_skills = actor.skills - last_skill new_skills.each {|skill| add_result_new_skill(actor, skill, new_skills) } end #============================================================================== # ■ スキルレベル制非使用時の処理 #============================================================================== else #-------------------------------------------------------------------------- # ○ 勝利後のスキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_for_victory(actor, skill) end #-------------------------------------------------------------------------- # ○ スキル使用後のスキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_for_use(actor, item) end;end end #============================================================================== # ■ Sprite_DamagePop #============================================================================== class Sprite_DamagePop #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- NWSK = 14 SKLU = 15 EQSK = 16 TEXTS[NWSK] = "NewSkill" TEXTS[SKLU] = "Skill-LevelUP" #-------------------------------------------------------------------------- # ☆ その他種別のテキスト #-------------------------------------------------------------------------- alias a1_passive_skill_sdp_other_kind_texts other_kind_texts def other_kind_texts(damage, kind, msg) return [TEXTS[NWSK], msg] if kind == NWSK return [TEXTS[SKLU], msg] if kind == SKLU a1_passive_skill_sdp_other_kind_texts(kind) end #-------------------------------------------------------------------------- # ☆ その他種別のカラー #-------------------------------------------------------------------------- alias a1_passive_skill_sdp_other_kind_color other_kind_color def other_kind_color(kind) return COLOR1 if kind == NWSK return COLOR1 if kind == SKLU a1_passive_skill_sdp_other_kind_color(kind) end end #============================================================================== # ■ Window_BattleLog #------------------------------------------------------------------------------ # 　戦闘の進行を実況表示するウィンドウです。枠は表示しませんが、便宜上ウィンド # ウとして扱います。 #============================================================================== class Window_BattleLog < Window_Selectable #-------------------------------------------------------------------------- # ○ 習得スキルの表示 #-------------------------------------------------------------------------- def display_new_skill(actor, skill) pop_damage(actor, Sprite_DamagePop::NWSK, skill.name, "HG創英角ﾎﾟｯﾌﾟ体") end end #============================================================================== # ■ Game_BattlerBase #------------------------------------------------------------------------------ # 　バトラーを扱う基本のクラスです。主に能力値計算のメソッドを含んでいます。こ # のクラスは Game_Battler クラスのスーパークラスとして使用されます。 #============================================================================== class Game_BattlerBase #-------------------------------------------------------------------------- # ★ スキルの消費 MP 計算 #-------------------------------------------------------------------------- def skill_mp_cost(skill) other_skill = level_use_skill(skill) return skill_mp_cost($data_skills[other_skill]) if other_skill return (skill.level_mp_cost[0] * mcr).to_i if skill.level_mp_cost.size == 1 (skill.level_mp_cost[use_skill_level_index(skill.id)] * mcr).to_i end #-------------------------------------------------------------------------- # ★ スキルの消費 TP 計算 #-------------------------------------------------------------------------- def skill_tp_cost(skill) other_skill = level_use_skill(skill) return skill_tp_cost($data_skills[other_skill]) if other_skill return skill.level_tp_cost[0] if skill.level_tp_cost.size == 1 skill.level_tp_cost[use_skill_level_index(skill.id)] end #-------------------------------------------------------------------------- # ☆ 二刀流の判定 #-------------------------------------------------------------------------- alias a1_passive_skill_gbb_dual_wield? dual_wield? def dual_wield? a1_passive_skill_gbb_dual_wield? || learnd_passive.has_key?("二刀流") end #-------------------------------------------------------------------------- # ☆ スキルの使用可能条件チェック #-------------------------------------------------------------------------- alias a1_passive_skill_gbb_skill_conditions_met? skill_conditions_met? def skill_conditions_met?(skill) return false unless a1_passive_skill_gbb_skill_conditions_met?(skill) return false unless skill_condition_for_actor(skill) if actor? return true if skill.use_condition_state.empty? return skill.use_condition_state.all? {|state_id| state?(state_id) } end #-------------------------------------------------------------------------- # ○ アクター向け使用可能条件チェック #-------------------------------------------------------------------------- def skill_condition_for_actor(skill) item_id = skill_use_item(skill) item_kind = skill.item_selection item = skill_use_item_select(item_kind, item_id) gold = skill_use_gold(skill) return false if item && $game_party.item_number(item) < calc_need_item_num(skill) return false if gold && $game_party.gold < gold return true end #-------------------------------------------------------------------------- # ○ 必要アイテムの個数チェック #-------------------------------------------------------------------------- def calc_need_item_num(skill) target_num(skill) * skill.repeats * skill_repeat_num(skill) end #-------------------------------------------------------------------------- # ○ ターゲットの数を取得 #-------------------------------------------------------------------------- def target_num(skill) return $game_troop.alive_members.size if skill.scope == 2 return 2 if skill.scope == 4 return 3 if skill.scope == 5 return 4 if skill.scope == 6 return $game_party.battle_members.size if skill.scope == 8 return 1 end #-------------------------------------------------------------------------- # ○ スキルで使用するアイテム #-------------------------------------------------------------------------- def skill_use_item_select(item_kind, item_id) return nil unless item_id && item_id > 0 return $data_weapons[item_id] if item_kind == "武器" return $data_armors[item_id] if item_kind == "防具" return $data_items[item_id] end #-------------------------------------------------------------------------- # ○ スキルレベル #-------------------------------------------------------------------------- def skill_level(skill_id) @skills_level ||= init_skills_level return @skills_level[skill_id] ? @skills_level[skill_id] : 1 end #-------------------------------------------------------------------------- # ○ スキルレベルの設定 #-------------------------------------------------------------------------- def set_skill_level(skill_id, level) @skills_level ||= init_skills_level @skills_level[skill_id] = level @skills_level.delete(skill_id) if @skills_level[skill_id] == 0 end #-------------------------------------------------------------------------- # ○ スキルレベルの初期化 #-------------------------------------------------------------------------- def init_skills_level @skills_level ||= battler.skills_level return @skills_level end #-------------------------------------------------------------------------- # ○ スキルレベルのIndexを取得 #-------------------------------------------------------------------------- def skill_level_index(skill_id) skill_level(skill_id) - 1 end #-------------------------------------------------------------------------- # ○ 使用するスキルレベル #-------------------------------------------------------------------------- def use_skill_level(skill_id) @use_skill_level ||= {} @use_skill_level[skill_id] ||= skill_level(skill_id) @use_skill_level[skill_id] = use_level(skill_id) return @use_skill_level[skill_id] end #-------------------------------------------------------------------------- # ○ 使用するスキルレベル #-------------------------------------------------------------------------- def use_level(skill_id) return [@use_skill_level[skill_id], skill_level(skill_id)].max if @force_use_level == "MAX" return @force_use_level if @force_use_level return skill_level(skill_id) if @use_skill_level[skill_id] > skill_level(skill_id) return @use_skill_level[skill_id] end #-------------------------------------------------------------------------- # ○ 使用するスキルレベルのIndex #-------------------------------------------------------------------------- def use_skill_level_index(skill_id) use_skill_level(skill_id) - 1 end #-------------------------------------------------------------------------- # ○ 強制使用レベルのクリア #-------------------------------------------------------------------------- def clear_force_use_level @force_use_level = nil end #-------------------------------------------------------------------------- # ○ 使用するスキルレベルの設定 #-------------------------------------------------------------------------- def set_use_skill_level(skill_id, level, force = nil) @force_use_level = force == "FIX" ? level : force return false if skill(skill_id).fix_use_level && !force @use_skill_level ||= {} @use_skill_level[skill_id] = level return true end #-------------------------------------------------------------------------- # ○ 覚えているパッシブスキル #-------------------------------------------------------------------------- def learnd_passive @learnd_passive ||= {} return @learnd_passive end #-------------------------------------------------------------------------- # ○ パッシブスキルのセットアップ #-------------------------------------------------------------------------- def setup_passive(kind, skill_id, values, flag = true) learnd_passive[kind] ||= {} passive = learnd_passive[kind] passive[skill_id] = values if flag passive.delete(skill_id) unless values learnd_passive.delete(kind) if learnd_passive[kind].empty? end #-------------------------------------------------------------------------- # ○ パッシブスキルを削除 #-------------------------------------------------------------------------- def delete_passive(kind, key) return unless learnd_passive[kind] return delete_passive_array(kind, key) if key.is_a?(Array) learnd_passive[kind].delete(key) learnd_passive.delete(kind) if learnd_passive[kind].empty? end #-------------------------------------------------------------------------- # ○ パッシブキーが配列の場合の削除 #-------------------------------------------------------------------------- def delete_passive_array(kind, key) keys = learnd_passive[kind].keys.select {|passive_key| passive_key.is_a?(Array) } keys = keys.select {|passive_key| passive_key.include?(key[0]) } keys.each {|passive_key| learnd_passive[kind].delete(passive_key) } learnd_passive.delete(kind) if learnd_passive[kind].empty? end #-------------------------------------------------------------------------- # ○ ステートのパッシブスキルリストの作成 #-------------------------------------------------------------------------- def create_state_passive delete_state_passive states.compact.each {|state| add_state_passive(state, state.id) } end #-------------------------------------------------------------------------- # ○ ステートのパッシブスキルを追加 #-------------------------------------------------------------------------- def add_state_passive(state, state_id) state.passive_effect.each_pair {|kind, values| setup_state_passive(kind, state_id, values)} if state.passive? end #-------------------------------------------------------------------------- # ○ ステートのパッシブスキルのセットアップ #-------------------------------------------------------------------------- def setup_state_passive(kind, state_id, values) learnd_passive[kind] ||= {} learnd_passive[kind][["state",state_id, learnd_passive[kind].keys.size]] = values end #-------------------------------------------------------------------------- # ○ ステートのパッシブスキルを削除 #-------------------------------------------------------------------------- def delete_state_passive max_index = states.size learnd_passive.keys.each {|kind| delete_passive(kind, ["state"]) } end #-------------------------------------------------------------------------- # ☆ リフレッシュ #-------------------------------------------------------------------------- alias a1_passive_skill_gbb_refresh refresh def refresh a1_passive_skill_gbb_refresh create_state_passive end #-------------------------------------------------------------------------- # ○ 使用する他のスキル #-------------------------------------------------------------------------- def level_use_skill(skill) return skill.level_use_skill[0] if skill.level_use_skill.size == 1 skill.level_use_skill[use_skill_level_index(skill.id)] end #-------------------------------------------------------------------------- # ○ スキルの繰り返し回数取得 #-------------------------------------------------------------------------- def skill_repeat_num(skill) return skill.repeat_num[0] if skill.repeat_num.size == 1 skill.repeat_num[use_skill_level_index(skill.id)] end #-------------------------------------------------------------------------- # ○ パッシブスキルの値を取得 #-------------------------------------------------------------------------- def passive_value(passive, skill_id) return passive[0] if passive.size == 1 passive[use_skill_level_index(skill_id)] end end #============================================================================== # ■ Game_Action #------------------------------------------------------------------------------ # 　戦闘行動を扱うクラスです。このクラスは Game_Battler クラスの内部で使用され # ます。 #============================================================================== class Game_Action #-------------------------------------------------------------------------- # ☆ スキルを設定 #-------------------------------------------------------------------------- alias a1_passive_skill_gb_set_skill set_skill def set_skill(skill_id) set_use_item($data_skills[skill_id]) if @subject.actor? set_use_gold($data_skills[skill_id]) if @subject.actor? a1_passive_skill_gb_set_skill(skill_id) end #-------------------------------------------------------------------------- # ○ スキルで使用したアイテム #-------------------------------------------------------------------------- def use_item @use_item end #-------------------------------------------------------------------------- # ○ スキルで使用したゴールド #-------------------------------------------------------------------------- def use_gold @use_gold end #-------------------------------------------------------------------------- # ○ スキルセレクト中 #-------------------------------------------------------------------------- def select_skill(flag) @select_skill = flag end #-------------------------------------------------------------------------- # ○ スキルで使用するアイテム #-------------------------------------------------------------------------- def set_use_item(skill) item_id = @subject.skill_use_item(skill) item_kind = skill.item_selection item_id = BattleManager.call_method(:open_item_window, item_kind, @subject, skill) if item_id == -1 && @select_skill @select_skill = false @use_item = @subject.skill_use_item_select(item_kind, item_id) end #-------------------------------------------------------------------------- # ○ スキルで使用するゴールド #-------------------------------------------------------------------------- def set_use_gold(skill) @use_gold = @subject.skill_use_gold(skill) end end #============================================================================== # ■ Game_Battler #------------------------------------------------------------------------------ # 　スプライトや行動に関するメソッドを追加したバトラーのクラスです。このクラス # は Game_Actor クラスと Game_Enemy クラスのスーパークラスとして使用されます。 #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # ○ 公開インスタンス変数 #-------------------------------------------------------------------------- attr_accessor :repeat_num #-------------------------------------------------------------------------- # ○ レベル倍率 #-------------------------------------------------------------------------- def rate(skill_id = current_action.item.id) retes = skill(skill_id).level_rate return retes[0] / 100.0 if retes.size == 1 return retes[skill_level_index(skill_id)] if skill(skill_id).use_now_level_rate retes[use_skill_level_index(skill_id)] / 100.0 end #-------------------------------------------------------------------------- # ○ スキルレベル #-------------------------------------------------------------------------- def s_lv(skill_id = current_action.item.id) skill_level(skill_id) end #-------------------------------------------------------------------------- # ○ アイテム価値 #-------------------------------------------------------------------------- def item_value(used_item = current_action.use_item) used_item ? used_item.item_value : 0 end #-------------------------------------------------------------------------- # ○ ゴールド #-------------------------------------------------------------------------- def gold(used_gold = current_action.use_gold) used_gold ? used_gold : 0 end #-------------------------------------------------------------------------- # ☆ スキル／アイテムの使用 # 行動側に対して呼び出され、使用対象以外に対する効果を適用する。 #-------------------------------------------------------------------------- alias a1_passive_skill_gb_use_item use_item def use_item(item) a1_passive_skill_gb_use_item(item) if @repeat_num == 0 end #-------------------------------------------------------------------------- # ☆ 使用効果［HP 回復］ #-------------------------------------------------------------------------- alias a1_passive_skill_gb_item_effect_recover_hp item_effect_recover_hp def item_effect_recover_hp(user, item, effect) last_hp = self.hp a1_passive_skill_gb_item_effect_recover_hp(user, item, effect) return unless user.current_action.item.is_a?(RPG::Skill) && user.current_action.use_item value = self.hp - last_hp @result.hp_damage += value value = (value * (user.rate / 100.0)).round.to_i @result.hp_damage -= value self.hp = last_hp + value end #-------------------------------------------------------------------------- # ☆ 使用効果［MP 回復］ #-------------------------------------------------------------------------- alias a1_passive_skill_gb_item_effect_recover_mp item_effect_recover_mp def item_effect_recover_mp(user, item, effect) last_mp = self.mp a1_passive_skill_gb_item_effect_recover_mp(user, item, effect) return unless user.current_action.item.is_a?(RPG::Skill) && user.current_action.use_item value = self.mp - last_mp @result.mp_damage += value value = (value * (user.rate / 100.0)).round.to_i @result.mp_damage -= value self.mp = last_mp + value end #-------------------------------------------------------------------------- # ○ スキルで使用するアイテムの取得 #-------------------------------------------------------------------------- def skill_use_item(skill) return nil end #-------------------------------------------------------------------------- # ○ スキルで使用するゴールドの取得 #-------------------------------------------------------------------------- def skill_use_gold(skill) return nil end end #============================================================================== # ■ Game_Actor #------------------------------------------------------------------------------ # 　アクターを扱うクラスです。このクラスは Game_Actors クラス（$game_actors） # の内部で使用され、Game_Party クラス（$game_party）からも参照されます。 #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- PARAMS_PASSIVE = A1_System::PassiveSkillConfig::PARAMS_PASSIVE XPARAMS_PASSIVE = A1_System::PassiveSkillConfig::XPARAMS_PASSIVE SPPARAMS_PASSIVE = A1_System::PassiveSkillConfig::SPPARAMS_PASSIVE USE_HAND_MASTARY = A1_System::PassiveSkillConfig::USE_HAND_MASTARY MIN_HAND_MASTARY = A1_System::PassiveSkillConfig::MIN_HAND_MASTARY ADD_HAND_MASTARY = A1_System::PassiveSkillConfig::ADD_HAND_MASTARY #-------------------------------------------------------------------------- # ☆ 通常能力値の基本値取得 #-------------------------------------------------------------------------- alias a1_passive_skill_ga_param_base param_base def param_base(param_id) a1_passive_skill_ga_param_base(param_id) + params_passive(PARAMS_PASSIVE[param_id]) end #-------------------------------------------------------------------------- # ☆ アイテムにかける追加要素 #-------------------------------------------------------------------------- alias a1_passive_skill_ga_ex_item_params ex_item_params def ex_item_params(item, param_id) @item_passive ||= {} plus = @item_passive[[param_id, e_type_name(item)]] ? 0 : params_equip_passive(item, param_id) @item_passive[[param_id, e_type_name(item)]] = true a1_passive_skill_ga_ex_item_params(item, param_id) + plus end #-------------------------------------------------------------------------- # ○ 通常能力値の加算値取得 #-------------------------------------------------------------------------- alias a1_passive_skill_ga_param_plus param_plus def param_plus(param_id) ret = a1_passive_skill_ga_param_plus(param_id) @item_passive = {} return ret end #-------------------------------------------------------------------------- # ○ 通常能力値の加算値のパッシブ増加値を取得 #-------------------------------------------------------------------------- def params_equip_passive(item, param_id) params_passive("#{e_type_name(item)}#{PARAMS_PASSIVE[param_id]}") end #-------------------------------------------------------------------------- # ○ 追加能力値の取得 #-------------------------------------------------------------------------- def xparam(xparam_id) super + params_passive(XPARAMS_PASSIVE[xparam_id]) / 100.0 end #-------------------------------------------------------------------------- # ○ 特殊能力値の取得 #-------------------------------------------------------------------------- def sparam(sparam_id) super + params_passive(SPPARAMS_PASSIVE[sparam_id]) / 100.0 end #-------------------------------------------------------------------------- # ○ 能力値のパッシブ増加値を取得 #-------------------------------------------------------------------------- def params_passive(passive_kind, ret = 0) passive = learnd_passive[passive_kind] return 0 unless passive passive.each_pair {|skill_id, values| ret += values[skill_level_index(skill_id)]} return ret end #-------------------------------------------------------------------------- # ☆ スキルの初期化 #-------------------------------------------------------------------------- alias a1_passive_skill_ga_init_skills init_skills def init_skills @learnd_passive = {} @skills_exp = {} a1_passive_skill_ga_init_skills end #-------------------------------------------------------------------------- # ☆ スキルを覚える #-------------------------------------------------------------------------- alias a1_passive_skill_ga_learn_skill learn_skill def learn_skill(skill_id) a1_passive_skill_ga_learn_skill(skill_id) skill = $data_skills[skill_id] set_skill_level(skill_id, skill_level(skill_id)) skill.passive_effect.each_pair {|kind, values| setup_passive(kind, skill_id, values)} if skill.passive? @skills_exp[skill_id] = 0 end #-------------------------------------------------------------------------- # ☆ スキルを忘れる #-------------------------------------------------------------------------- alias a1_passive_skill_ga_forget_skill forget_skill def forget_skill(skill_id) a1_passive_skill_ga_forget_skill(skill_id) skill = $data_skills[skill_id] set_skill_level(skill_id, 0) skill.passive_effect.each_pair {|kind, value| setup_passive(kind, skill_id, false)} if skill.passive? @skills_exp.delete(skill_id) end #-------------------------------------------------------------------------- # ○ 装備品のパッシブスキルリストの作成 #-------------------------------------------------------------------------- def create_equip_passive delete_equip_passive equips.compact.each {|equip| add_equip_passive(equip, equips.index(equip)) } end #-------------------------------------------------------------------------- # ○ 装備品のパッシブスキルを追加 #-------------------------------------------------------------------------- def add_equip_passive(equip, index) equip.passive_effect.each_pair {|kind, values| setup_equip_passive(kind, index, values)} if equip.passive? end #-------------------------------------------------------------------------- # ○ 装備品のパッシブスキルのセットアップ #-------------------------------------------------------------------------- def setup_equip_passive(kind, index, values) learnd_passive[kind] ||= {} learnd_passive[kind][["equip",index, learnd_passive[kind].keys.size]] = values end #-------------------------------------------------------------------------- # ○ 装備品のパッシブスキルを削除 #-------------------------------------------------------------------------- def delete_equip_passive max_index = equips.size learnd_passive.keys.each {|kind| delete_passive(kind, ["equip"]) } end #-------------------------------------------------------------------------- # ○ パッシブスキルを削除 #-------------------------------------------------------------------------- def delete_passive(kind, key) return unless learnd_passive[kind] return delete_passive_array(kind, key) if key.is_a?(Array) learnd_passive[kind].delete(key) learnd_passive.delete(kind) if learnd_passive[kind].empty? end #-------------------------------------------------------------------------- # ○ パッシブキーが配列の場合の削除 #-------------------------------------------------------------------------- def delete_passive_array(kind, key) keys = learnd_passive[kind].keys.select {|passive_key| passive_key.is_a?(Array) } keys = keys.select {|passive_key| passive_key.include?(key[0]) } keys.each {|passive_key| learnd_passive[kind].delete(passive_key) } learnd_passive.delete(kind) if learnd_passive[kind].empty? end #-------------------------------------------------------------------------- # ○ 同じ要素のスキルから最大値を取得 #-------------------------------------------------------------------------- def max_passive_value(passive) return 0 unless passive passive.keys.inject([]) {|r, id| r |= [passive_value(passive[id], id)]}.max end #-------------------------------------------------------------------------- # ○ スキル経験値アップ #-------------------------------------------------------------------------- def skill_exp_gain_with_all_passive(skill, exp = 1) passive_exp_gain(exp) skill_gain_exp(skill, exp) end #-------------------------------------------------------------------------- # ○ パッシブスキル経験値アップ #-------------------------------------------------------------------------- def passive_exp_gain(exp) passive = @skills_exp.keys.select {|id| $data_skills[id].passive? } passive.each {|id| skill_gain_exp($data_skills[id], exp) } end #-------------------------------------------------------------------------- # ○ スキル経験値アップ #-------------------------------------------------------------------------- def skill_gain_exp(skill, exp) return equip_skill_gain_exp(skill, exp) if equip_skill?(skill) && !skills.include?(skill) return unless exp_gain?(skill) need_exp = need_skill_exp(skill) @skills_exp[skill.id] += exp dis_exp = @skills_exp[skill.id] - need_exp skill_level_up(skill.id, dis_exp) if dis_exp >= 0 end #-------------------------------------------------------------------------- # ○ スキルレベルアップ #-------------------------------------------------------------------------- def skill_level_up(skill_id, dis_exp) @skills_level ||= init_skills_level @use_skill_level[skill_id] += 1 if @skills_level[skill_id] == use_skill_level(skill_id) @skills_level[skill_id] += 1 @levelup_skill ||= [] @levelup_skill.push(skill_id) @skills_exp[skill_id] = dis_exp check_new_skill(skill_id) end #-------------------------------------------------------------------------- # ○ 習得スキルのチェック #-------------------------------------------------------------------------- def check_new_skill(skill_id) new_skills = $game_skill_tree.condition_skill(skill_id) new_skills.each {|new_skill| learn_new_skill(new_skill) } end #-------------------------------------------------------------------------- # ○ 新しいスキルを覚える #-------------------------------------------------------------------------- def learn_new_skill(new_skill) return unless skill(new_skill).learn_condition.all? {|condition| check_learn_condition(condition) } learn_skill(new_skill) end #-------------------------------------------------------------------------- # ○ 習得条件のチェック #-------------------------------------------------------------------------- def check_learn_condition(condition) return false unless @skills_level[condition[0]] @skills_level[condition[0]] >= condition[1] end #-------------------------------------------------------------------------- # ○ レベルアップしたスキルの取得 #-------------------------------------------------------------------------- def levelup_skill @levelup_skill ||= [] return @levelup_skill end #-------------------------------------------------------------------------- # ○ レベルアップしたスキルのクリア #-------------------------------------------------------------------------- def clear_levelup_skills @levelup_skill = nil end #-------------------------------------------------------------------------- # ○ スキル経験値の取得 #-------------------------------------------------------------------------- def skill_exp(skill_id) @skills_exp[skill_id] end #-------------------------------------------------------------------------- # ○ スキル経験値が増える？ #-------------------------------------------------------------------------- def exp_gain?(skill) need_exp = need_skill_exp(skill) need_exp && need_exp > 0 && skill.id != guard_skill_id && skill.id != attack_skill_id && skills.include?(skill) end #-------------------------------------------------------------------------- # ○ 次までのスキル経験値の取得 #-------------------------------------------------------------------------- def need_skill_exp(skill) skill.need_exp[now_skill_level(skill.id)] end #-------------------------------------------------------------------------- # ○ 現在のスキルレベル #-------------------------------------------------------------------------- def now_skill_level(skill_id) skill_level_index(skill_id) end #-------------------------------------------------------------------------- # ○ 装備スキル #-------------------------------------------------------------------------- def equip_skills create_equip_skill_list unless @equip_skills @equip_skills.keys.inject([]) {|r, id| r |= [skill(id)] } end #-------------------------------------------------------------------------- # ○ 装備スキル？ #-------------------------------------------------------------------------- def equip_skill?(skill) create_equip_skill_list unless @equip_skills @equip_skills.has_key?(skill.id) end #-------------------------------------------------------------------------- # ○ 装備スキルリストの作成 #-------------------------------------------------------------------------- def create_equip_skill_list @equip_skills = {} equips.compact.each {|equip| equip.learn_skills.each {|data| setup_equip_skill(data, equip) } } end #-------------------------------------------------------------------------- # ○ 装備スキルのセットアップ #-------------------------------------------------------------------------- def setup_equip_skill(data, equip) skill_id = data.is_a?(Array) ? data[0] : data skill_lv = data.is_a?(Array) ? data[1] : 1 @equip_skills[skill_id] ||= skill_lv @equip_skills[skill_id] = skill_lv if @equip_skills[skill_id] < skill_lv end #-------------------------------------------------------------------------- # ○ スキルレベル #-------------------------------------------------------------------------- def skill_level(skill_id) return super unless equip_skill?(skill(skill_id)) return [super, @equip_skills[skill_id]].max end #-------------------------------------------------------------------------- # ○ 装備スキルの必要経験値 #-------------------------------------------------------------------------- def need_equip_skill_exp(skill) skill.need_learn_exp end #-------------------------------------------------------------------------- # ○ 装備スキルの経験値 #-------------------------------------------------------------------------- def equip_skill_exp(skill_id) setup_equip_skill_exp(skill_id) return @equip_skill_exp[skill_id] end #-------------------------------------------------------------------------- # ○ 装備スキル経験値のセットアップ #-------------------------------------------------------------------------- def setup_equip_skill_exp(skill_id) @equip_skill_exp ||= {} @equip_skill_exp[skill_id] ||= 0 end #-------------------------------------------------------------------------- # ○ 装備スキルの経験値アップ #-------------------------------------------------------------------------- def equip_skill_gain_exp(skill, exp) setup_equip_skill_exp(skill.id) need_exp = need_equip_skill_exp(skill) return if need_exp == 0 @equip_skill_exp[skill.id] += exp learn_equip_skill(skill) if @equip_skill_exp[skill.id] >= need_exp end #-------------------------------------------------------------------------- # ○ 装備スキルを覚える #-------------------------------------------------------------------------- def learn_equip_skill(skill) learn_skill(skill.id) @equip_skills.delete(skill.id) @equip_skill_exp.delete(skill.id) @equip_learn_skills ||= [] @equip_learn_skills.push(skill.id) end #-------------------------------------------------------------------------- # ○ 覚えた装備スキル #-------------------------------------------------------------------------- def equip_learn_skills @equip_learn_skills ||= [] @equip_learn_skills.inject([]) {|r, id| r |= [skill(id)] } end #-------------------------------------------------------------------------- # ○ 覚えた装備スキルのクリア #-------------------------------------------------------------------------- def clear_equip_learn_skills @equip_learn_skills = [] end #-------------------------------------------------------------------------- # ☆ 装備できない装備品を外す # item_gain : 外した装備品をパーティに戻す #-------------------------------------------------------------------------- alias a1_passive_skill_ga_release_unequippable_items release_unequippable_items def release_unequippable_items(item_gain = true) a1_passive_skill_ga_release_unequippable_items(item_gain) create_equip_skill_list create_equip_passive end #-------------------------------------------------------------------------- # ○ スキル使用コストの支払い #-------------------------------------------------------------------------- def pay_skill_cost(skill) super item = current_action.use_item gold = current_action.use_gold skill = current_action.item num = current_action.targets.size * skill.repeats * skill_repeat_num(skill) $game_party.lose_item(item, num) if item $game_party.lose_gold(gold) if gold end #-------------------------------------------------------------------------- # ☆ スキルの必要武器を装備しているか #-------------------------------------------------------------------------- alias a1_passive_skill_ga_skill_wtype_ok? skill_wtype_ok? def skill_wtype_ok?(skill) a1_passive_skill_ga_skill_wtype_ok?(skill) || equip_skill?(skill) end #-------------------------------------------------------------------------- # ○ スキルで使用するアイテムの取得 #-------------------------------------------------------------------------- def skill_use_item(skill) return skill.level_use_item[0] if skill.level_use_item.size == 1 skill.level_use_item[use_skill_level_index(skill.id)] end #-------------------------------------------------------------------------- # ○ スキルで使用するゴールドの取得 #-------------------------------------------------------------------------- def skill_use_gold(skill) return skill.level_use_gold[0] if skill.level_use_gold.size == 1 skill.level_use_gold[use_skill_level_index(skill.id)] end #============================================================================== # ■ 装備拡張インポート時処理 #============================================================================== if $imported["A1_ConsumerEquip"] #-------------------------------------------------------------------------- # ○ 利き腕と武器が合致？ #-------------------------------------------------------------------------- alias a1_passive_skill_ga_dominant_calc_param_rate calc_param_rate def calc_param_rate(value, item) return a1_passive_skill_ga_dominant_calc_param_rate(value, item) if use_ex_equip_calc?(item) return value - value * hand_rate[weapons.index(item)] end #-------------------------------------------------------------------------- # ○ 「装備拡張」の計算式を使う？ #-------------------------------------------------------------------------- def use_ex_equip_calc?(item) !USE_HAND_MASTARY || !two_sword_style? || item.etype_id == CONSUMA_EQUIP end #-------------------------------------------------------------------------- # ☆ 二刀流の利き腕のレート #-------------------------------------------------------------------------- alias a1_passive_skill_ga_dominant_dual_wirld_rate dominant_dual_wirld_rate def dominant_dual_wirld_rate(index) return a1_passive_skill_ga_dominant_dual_wirld_rate(index) unless USE_HAND_MASTARY return dual_wirld_rate[index] end #-------------------------------------------------------------------------- # ☆ 二刀流時の攻撃力レート #-------------------------------------------------------------------------- alias a1_passive_skill_ga_dual_wirld_rate dual_wirld_rate def dual_wirld_rate return a1_passive_skill_ga_dual_wirld_rate unless USE_HAND_MASTARY r_mastary = [max_passive_value(learnd_passive["右手修練"]) / 100.0, MIN_HAND_MASTARY].max l_mastary = [max_passive_value(learnd_passive["左手修練"]) / 100.0, MIN_HAND_MASTARY].max return [r_mastary + ADD_HAND_MASTARY, l_mastary] if dominant_hand == "右" return [l_mastary + ADD_HAND_MASTARY, r_mastary] if dominant_hand == "左" return [r_mastary + ADD_HAND_MASTARY, l_mastary + ADD_HAND_MASTARY] if dominant_hand == "両" end;end end #============================================================================== # ■ Window_Combo #============================================================================== class Window_Combo < Window_Base #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- ARROW = ["↑","←","→","↓"] COMBO_INPUT_COUNT = A1_System::PassiveSkillConfig::COMBO_INPUT_COUNT #-------------------------------------------------------------------------- # ○ オブジェクト初期化 #-------------------------------------------------------------------------- def initialize x = (Graphics.width - 250) / 2 y = (Graphics.height - fitting_height(4)) / 2 super(x, y, 250, fitting_height(4)) self.openness = 0 @actor = nil @input_count = 0 end #-------------------------------------------------------------------------- # ○ データセットアップ #-------------------------------------------------------------------------- def setup_data(actor, skill) @actor = actor @skill = skill @combo_skills = [] refresh end #-------------------------------------------------------------------------- # ○ コンボアイテム取得 #-------------------------------------------------------------------------- def item @combo_skills end #-------------------------------------------------------------------------- # ○ フレーム更新 #-------------------------------------------------------------------------- def update return if self.visible == false super self.visible = false if self.openness == 0 return if @input_count == 0 @input_count -= 1 if @input_count > 0 update_input return if @input_count > 0 close if @input_count == 0 end #-------------------------------------------------------------------------- # ○ 入力の更新 #-------------------------------------------------------------------------- def update_input next_combo(3) if Input.trigger?(:DOWN) next_combo(0) if Input.trigger?(:UP) next_combo(2) if Input.trigger?(:RIGHT) next_combo(1) if Input.trigger?(:LEFT) end #-------------------------------------------------------------------------- # ○ 次のコンボに遷移 #-------------------------------------------------------------------------- def next_combo(index) Input.update @input_count = 0 return close unless @combo_skills[index] Sound.play_ok close call_method(:next_combo, @combo_skills[index]) end #-------------------------------------------------------------------------- # ○ オープン #-------------------------------------------------------------------------- def open self.visible = true super end #-------------------------------------------------------------------------- # ○ リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear @skill.combo_skill.each_with_index {|id, i | draw_combo(id, i) } @input_count = COMBO_INPUT_COUNT end #-------------------------------------------------------------------------- # ○ コンボスキルの描画 #-------------------------------------------------------------------------- def draw_combo(skill_id, index) draw_text(0, line_height * 0, contents.width, line_height, "#{ARROW[index]}：#{set_skill_name(skill_id, index)}") end #-------------------------------------------------------------------------- # ○ スキル名のセット #-------------------------------------------------------------------------- def set_skill_name(skill_id, index) skill = $data_skills[skill_id] return "" unless skill && @actor.usable?(skill) @combo_skills[index] = skill return skill.name end end #============================================================================== # ■ Window_SkillList #------------------------------------------------------------------------------ # 　スキル画面で、使用できるスキルの一覧を表示するウィンドウです。 #============================================================================== class Window_SkillList < Window_Selectable #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- USE_SKILL_LEVEL = A1_System::PassiveSkillConfig::USE_SKILL_LEVEL COST_X = 230 LEVEL_X = 190 KIND_X = 330 EXP_X = 440 EQUIP_EXP_X = 440 #-------------------------------------------------------------------------- # ★ 桁数の取得 #-------------------------------------------------------------------------- def col_max return 1 end #-------------------------------------------------------------------------- # ☆ スキルを許可状態で表示するかどうか #-------------------------------------------------------------------------- alias a1_passive_skill_wsl_enable? enable? def enable?(item) a1_passive_skill_wsl_enable?(item) && !item.combo_only end #-------------------------------------------------------------------------- # ☆ スキルをリストに含めるかどうか #-------------------------------------------------------------------------- alias a1_passive_skill_wsl_include? include? def include?(item) return false unless a1_passive_skill_wsl_include?(item) return false if ($game_party.in_battle && item.passive?) || item.hide_skill return true end #-------------------------------------------------------------------------- # ○ 装備スキルをリストに含めるかどうか #-------------------------------------------------------------------------- def equip_skills_include?(item) include?(item) && !@actor.skills.include?(item) end #-------------------------------------------------------------------------- # ☆ スキルリストの作成 #-------------------------------------------------------------------------- alias a1_passive_skill_wsl_make_item_list make_item_list def make_item_list a1_passive_skill_wsl_make_item_list @data += @actor ? @actor.equip_skills.select {|skill| equip_skills_include?(skill) } : [] end #-------------------------------------------------------------------------- # ☆ スキルの使用コストを描画 #-------------------------------------------------------------------------- alias a1_passive_skill_wsl_draw_skill_cost draw_skill_cost def draw_skill_cost(rect, skill) rect.x = COST_X rect.width = 80 a1_passive_skill_wsl_draw_skill_cost(rect, skill) end #-------------------------------------------------------------------------- # ☆ 項目の描画 #-------------------------------------------------------------------------- alias a1_passive_skill_wsl_draw_item draw_item def draw_item(index) a1_passive_skill_wsl_draw_item(index) skill = @data[index] return unless skill rect = item_rect(index) rect.x += 230 draw_equip_skill_exp(rect, skill) if equip_skill?(skill) draw_skill_level(rect, skill) if USE_SKILL_LEVEL draw_skill_kind(rect, skill) draw_skill_exp(rect, skill) if !equip_skill?(skill) && USE_SKILL_LEVEL end #-------------------------------------------------------------------------- # ○ 装備スキル？ #-------------------------------------------------------------------------- def equip_skill?(skill) @actor.equip_skill?(skill) && !@actor.skills.include?(skill) end #-------------------------------------------------------------------------- # ○ スキル種別 の描画 #-------------------------------------------------------------------------- def draw_skill_kind(rect, skill) rect.x = KIND_X rect.width = 100 change_color(normal_color) text = show_skill_kind(skill) draw_text(rect, text) end #-------------------------------------------------------------------------- # ○ 描画するスキル種別 #-------------------------------------------------------------------------- def show_skill_kind(skill) skill.passive? ? "Passive" : skill.combo_only ? "ComboOnly" : "Active" end #-------------------------------------------------------------------------- # ○ 装備習得スキルのスキルレベル の描画 #-------------------------------------------------------------------------- def draw_equip_skill_exp(rect, skill) rect.x = EQUIP_EXP_X need_exp = @actor.need_equip_skill_exp(skill) change_color(crisis_color) return draw_text(rect, "---/---") unless need_exp && need_exp > 0 now_exp = @actor.equip_skill_exp(skill.id) draw_text(rect, sprintf("%3d/%3d", now_exp, need_exp)) end #============================================================================== # ■ スキルレベル制使用時の処理 #============================================================================== if A1_System::PassiveSkillConfig::USE_SKILL_LEVEL #-------------------------------------------------------------------------- # ○ スキルレベル の描画 #-------------------------------------------------------------------------- def draw_skill_level(rect, skill) text = skill.fix_use_level ? sprintf("%2d", @actor.use_skill_level(skill.id)) : use_skill_level_with_max(skill) rect.x = LEVEL_X rect.width = 100 change_color(normal_color) draw_text(rect, "Lv", 0) draw_text(rect, text, 1) end #-------------------------------------------------------------------------- # ○ 最大込みスキルレベル の取得 #-------------------------------------------------------------------------- def use_skill_level_with_max(skill) sprintf("%2d/%2d", @actor.use_skill_level(skill.id), @actor.skill_level(skill.id)) end #-------------------------------------------------------------------------- # ○ カーソルを右に移動 #-------------------------------------------------------------------------- def cursor_right(wrap = false) return Sound.play_buzzer if item.fix_use_level || @actor.use_skill_level(item.id) == 1 Sound.play_cursor @actor.set_use_skill_level(item.id, @actor.use_skill_level(item.id) - 1) refresh end #-------------------------------------------------------------------------- # ○ カーソルを左に移動 #-------------------------------------------------------------------------- def cursor_left(wrap = false) return Sound.play_buzzer if item.fix_use_level || @actor.use_skill_level(item.id) == @actor.skill_level(item.id) Sound.play_cursor @actor.set_use_skill_level(item.id, @actor.use_skill_level(item.id) + 1) refresh end #-------------------------------------------------------------------------- # ○ スキル経験値の描画 #-------------------------------------------------------------------------- def draw_skill_exp(rect, skill) rect.x = EXP_X need_exp = @actor.need_skill_exp(skill) return draw_text(rect, "---/---") unless need_exp && need_exp > 0 now_exp = @actor.skill_exp(skill.id) draw_text(rect, sprintf("%3d/%3d", now_exp, need_exp)) end;end end #============================================================================== # ■ リザルトウィンドウ対応処理 #============================================================================== if $imported["A1_ResultWindow"] #============================================================================== # ■ Scene_Battle #------------------------------------------------------------------------------ # 　バトル画面の処理を行うクラスです。 #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # ☆ リザルトウィンドウの作成 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_create_result_window create_result_window def create_result_window @window_lvup_skill = Window_ResultLvupSkill.new @window_master_skill = Window_ResultMasterSkill.new a1_passive_skill_sb_create_result_window end #-------------------------------------------------------------------------- # ☆ リザルトウィンドウの位置設定 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_posting_result_window posting_result_window def posting_result_window a1_passive_skill_sb_posting_result_window @window_lvup_skill.resize(@window_result) @window_master_skill.resize(@window_result) @window_master_skill.y += @window_lvup_skill.height if @window_lvup_skill.lvup_skills.size > 0 @window_new_skill.y += @window_lvup_skill.height if @window_lvup_skill.lvup_skills.size > 0 @window_new_skill.y += @window_master_skill.height if @window_master_skill.master_skills.size > 0 end #-------------------------------------------------------------------------- # ☆ リザルトウィンドウの処理 #-------------------------------------------------------------------------- alias a1_passive_skill_sb_process_result process_result def process_result setup_lvup_skills display_skill_exp a1_passive_skill_sb_process_result end #-------------------------------------------------------------------------- # ○ リザルトウィンドウを閉じる #-------------------------------------------------------------------------- alias a1_passive_skill_sb_close_result_window close_result_window def close_result_window a1_passive_skill_sb_close_result_window @window_lvup_skill.close @window_master_skill.close end #-------------------------------------------------------------------------- # ○ レベルアップしたスキルのセットアップ #-------------------------------------------------------------------------- def setup_lvup_skills $game_party.all_members.each {|actor| setup_lvup_skill_window(actor) } open_lvup_skill_window unless @window_lvup_skill.lvup_skills.empty? end #-------------------------------------------------------------------------- # ○ レベルアップスキルウィンドウのセットアップ #-------------------------------------------------------------------------- def setup_lvup_skill_window(actor) actor.levelup_skill.each {|id| @window_lvup_skill.add_skills($data_skills[id], actor)} end #-------------------------------------------------------------------------- # ○ レベルアップスキルウィンドウのオープン #-------------------------------------------------------------------------- def open_lvup_skill_window LVUP_SE.play @window_lvup_skill.open @window_lvup_skill.refresh posting_result_window end #-------------------------------------------------------------------------- # ★ リザルトウィンドウの位置再設定(リザルトウィンドウの再定義) #-------------------------------------------------------------------------- def reposting_result_window(size) return unless skill_windows_height > @window_result.height + @window_gold.height height = (size * @window_new_skill.line_height) + (@window_lvup_skill.lvup_skills.size * @window_lvup_skill.line_height) return if @window_result.y - height < 0 @window_result.y -= height posting_result_window end #-------------------------------------------------------------------------- # ○ レベルアップ/Newスキルウィンドウの高さの合計 #-------------------------------------------------------------------------- def skill_windows_height @window_new_skill.height + @window_lvup_skill.height end #-------------------------------------------------------------------------- # ○ 獲得したスキル経験値の表示 #-------------------------------------------------------------------------- def display_skill_exp return unless A1_System::PassiveSkillConfig::DRAW_RESULT @window_result.total_skill_exp = skill_exp_total end #-------------------------------------------------------------------------- # ○ リザルトウィンドウに新スキルを追加する #-------------------------------------------------------------------------- def add_result_new_skill(actor, skill, new_skills) LVUP_SE.play @window_new_skill.add_skills(skill, actor) @window_new_skill.open @window_new_skill.refresh reposting_result_window(new_skills.size) end #-------------------------------------------------------------------------- # ○ リザルトウィンドウに習得した装備スキルを追加する #-------------------------------------------------------------------------- def add_result_learn_skill(actor, skill) LVUP_SE.play @window_master_skill.add_skills(skill, actor) @window_master_skill.open @window_master_skill.refresh reposting_result_window(@window_master_skill.master_skills.size) end end #============================================================================== # ■ リザルト描画設定時処理 #============================================================================== if A1_System::PassiveSkillConfig::DRAW_RESULT #============================================================================== # ■ Window_Result #============================================================================== class Window_Result < Window_Base #-------------------------------------------------------------------------- # ○ 定数 #-------------------------------------------------------------------------- SKILL_EXP_NAME = A1_System::PassiveSkillConfig::SKILL_EXP_NAME #-------------------------------------------------------------------------- # ○ 経験値・Goloなどの項目数合計 #-------------------------------------------------------------------------- def bottom_num return 3 end #-------------------------------------------------------------------------- # ○ 水平線のy座標取得 #-------------------------------------------------------------------------- def horz_line_y skill_exp_y - 1 end #-------------------------------------------------------------------------- # ○ 経験値情報のリフレッシュ #-------------------------------------------------------------------------- alias a1_passive_skill_wr_refresh_exp refresh_exp def refresh_exp(exp, gold) a1_passive_skill_wr_refresh_exp(exp, gold) draw_text(INFOS_X, skill_exp_y, INFOS_WIDTH, line_height, @total_skill_exp, 2) end #-------------------------------------------------------------------------- # ○ 獲得経験値/Goldの見出しの描画 #-------------------------------------------------------------------------- alias a1_passive_skill_wr_draw_caption draw_caption def draw_caption a1_passive_skill_wr_draw_caption draw_text(INFOS_X, skill_exp_y, INFOS_WIDTH, line_height, SKILL_EXP_NAME) end #-------------------------------------------------------------------------- # ○ 獲得スキル経験値の設定 #-------------------------------------------------------------------------- def total_skill_exp=(value) @total_skill_exp = value end #-------------------------------------------------------------------------- # ○ 獲得スキル経験値表示y座標取得 #-------------------------------------------------------------------------- def skill_exp_y exp_y - line_height + 4 end end;end #============================================================================== # ■ Window_ResultMasterSkill #============================================================================== class Window_ResultMasterSkill < Window_ResultNewSkill #-------------------------------------------------------------------------- # ○ レベルアップしたスキルの取得 #-------------------------------------------------------------------------- def master_skills @skills end #-------------------------------------------------------------------------- # ○ リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear @skills.delete_at(0) while new_height > Graphics.height / 2 self.height = new_height create_contents draw_text(0, 0, self.contents.width, line_height, "MasterSkill!!", 1) @skills.each_with_index {|skill, i| drow_skill_info(skill, i) } end end #============================================================================== # ■ Window_ResultLvupSkill #============================================================================== class Window_ResultLvupSkill < Window_ResultNewSkill #-------------------------------------------------------------------------- # ○ レベルアップしたスキルの取得 #-------------------------------------------------------------------------- def lvup_skills @skills end #-------------------------------------------------------------------------- # ○ リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear @skills.delete_at(0) while new_height > Graphics.height / 2 self.height = new_height create_contents draw_text(0, 0, self.contents.width, line_height, "LvUPSkill!!", 1) @skills.each_with_index {|skill, i| drow_skill_info(skill, i) } end end;end end