#============================================================================== # ■スキルメモライズトライ for RGSS3 Ver1.80-β #　□作成者 kure # #　呼び出し方法　SceneManager.call(Scene_SkillMemorize3) #　 #============================================================================== $kure_integrate_script = {} if $kure_integrate_script == nil $kure_integrate_script[:Memorize3] = 1 p "スキルメモライズトライ" #-------------------------------------------------------------------------- # ★ 設定項目(各設定の値を変更してください) #-------------------------------------------------------------------------- module KURE module SkillMemorize3 #初期設定------------------------------------------------------------------- CHAIN_MEMORIZE = [] ; ELEMENT_MEMORIZE = [] ; MEM_SETTING = [] #動作設定------------------------------------------------------------------- #スキルタイプ0を使用するかどうか(0=使用しない　1=使用する) USE_TYPE_0 = 0 #スキルタイプ0のコマンド名 TYPE_0_NAME = "スキル" #スキルタイプ0に含めるスキルタイプ TYPE_0_INCLUDE = [1,2] #メモライズ適用範囲(0=常に適用 1=戦闘中のみ) ADOPT_MEMORIZE = 0 #LvUP時のメモライズ自動登録(0=OFF、1=ON) AUTO_MEMORIZE = 1 #メモライズ自動登録外のスキルタイプ NOT_AUTO_MEMORIZE = [] #メモライズの設定----------------------------------------------------------- #MEM_SETTING[スキルタイプID] = [項目1,項目2,…] #項目1　→　メモライズ容量ゲージの表示 (0=表示しない 1=表示する) #項目2　→　コマンドに追加するか (0=追加しない 1=追加する) #項目3　→　メモライズ数制限 (0=適用しない 1=適用する) #項目4　→　メモライズ容量制限 (0=適用しない 1=適用する) # #項目5　→　メモライズ数の設定　[設定1,設定2,設定3] #　　　　　　設定1　→　メモライズ基礎最大数 #　　　　　　設定2　→　メモライズ数のLv補正 (少数可) #　　　　　　設定3　→　メモライズ数上限 (0=上限なし) # #項目6　→　メモライズ容量の設定　[設定1,設定2,設定3] #　　　　　　設定1　→　メモライズ基礎容量 #　　　　　　設定2　→　メモライズ容量のLv補正 (少数可) #　　　　　　設定3　→　メモライズ容量上限 (0=上限なし) MEM_SETTING[0] = [1, 1, 0, 1, [2,0,0], [50,0.1,0]] MEM_SETTING[1] = [1, 1, 0, 1, [2,0,0], [50,0.1,0]] MEM_SETTING[2] = [1, 1, 1, 1, [3,0,0], [50,0.1,0]] MEM_SETTING[3] = [1, 1, 1, 0, [4,0,0], [50,0.1,0]] MEM_SETTING[4] = [1, 1, 0, 1, [1,0,0], [50,0.1,0]] MEM_SETTING[5] = [1, 1, 0, 1, [2,0,0], [50,0.1,0]] MEM_SETTING[6] = [1, 1, 0, 1, [3,0,0], [50,0.1,0]] #メモライズ容量の表示名----------------------------------------------------- MEM_CAP_NAME = "MC" #スキルに関する設定----------------------------------------------------------- #チェインメモライズ #CHAIN_MEMORIZE[(0〜順に数字を入れる)] = [追加スキルID,要求スキルID,要求スキルID,…] CHAIN_MEMORIZE[0] = [72,11] CHAIN_MEMORIZE[1] = [56,80] #エレメントシフトメモライズ #ELEMENT_MEMORIZE[(0〜順に数字を入れる)] = [追加スキルID, [要求属性ID,要求属性値], …] ELEMENT_MEMORIZE[0] = [57,[4,10]] #ID57の習得に属性ID4の値が10必要 end end #メモ欄処理モジュール-------------------------------------------------------- module KURE #-------------------------------------------------------------------------- # ★ 数値配列に畳む(追加定義) #-------------------------------------------------------------------------- def self.arr_num_slice(arr) result_arr = Array.new unless arr == [] and arr.empty? arr.flatten! arr.each{|value| value.scan(/\d+/).each { |num| result_arr.push(num.to_i)}} end return result_arr end #-------------------------------------------------------------------------- # ★ メモ欄取得操作の定義(11式ID加算配列の指定IDを返す)(追加定義) #-------------------------------------------------------------------------- def self.memo_11_23_id_command(cheak_note, word, id) result = Array.new while cheak_note do cheak_note.match(/<#{word}\s?(\d+)\s?,\s?([-]?\d+)\s?>/) if $1 && $2 result[$1.to_i] ||= 0 result[$1.to_i] += $2.to_i end cheak_note = $' end return result[id] ? result[id] : 0 end end #============================================================================== # ●■ RPG::BaseItem(追加定義集積) #============================================================================== class RPG::BaseItem #-------------------------------------------------------------------------- # ★ 記憶容量増加の定義(追加定義) #-------------------------------------------------------------------------- def gain_memorize_capacity(cheak_note, id) KURE.memo_11_23_id_command(cheak_note, "追加記憶容量", id) end #-------------------------------------------------------------------------- # ★ 記憶容量増加の定義(追加定義) #-------------------------------------------------------------------------- def gain_memorize_num(cheak_note, id) KURE.memo_11_23_id_command(cheak_note, "追加記憶数", id) end end #============================================================================== # ■ RPG::Skill(追加定義) #============================================================================== class RPG::Skill < RPG::UsableItem #-------------------------------------------------------------------------- # ★ 記憶容量の定義(追加定義) #-------------------------------------------------------------------------- def memorize_capacity @note.match(/<記憶容量\s?(\d+)\s?>/) return $1 ? $1.to_i : 0 end #-------------------------------------------------------------------------- # ★ 共存不可の定義(追加定義) #-------------------------------------------------------------------------- def not_coexist KURE.arr_num_slice(@note.scan(/<共存不可\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end #-------------------------------------------------------------------------- # ★ 固有スキルの定義(追加定義) #-------------------------------------------------------------------------- def uniq_skill? @note.include?("<固有スキル>") end #-------------------------------------------------------------------------- # ★ 自動メモライズ不可の定義(追加定義) #-------------------------------------------------------------------------- def not_auto_memorize @note.include?("<自動メモライズ不可>") end #-------------------------------------------------------------------------- # ★ 属変動値の定義(追加定義) #-------------------------------------------------------------------------- def element_value result = Array.new cheak_note = @note while cheak_note do cheak_note.match(/<属性変動値\s?(\d+)\s?,\s?([-]?\d+)\s?>/) result.push([$1.to_i, $2.to_i]) if $1 && $2 cheak_note = $' end return result end end #============================================================================== # ■ RPG::Actor(追加定義) #============================================================================== class RPG::Actor < RPG::BaseItem #-------------------------------------------------------------------------- # ★ 初期メモライズの定義(追加定義) #-------------------------------------------------------------------------- def first_memorize KURE.arr_num_slice(@note.scan(/<初期メモライズ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end end #============================================================================== # ■ Game_Actor(追加定義) #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # ◎ 装備の変更(エイリアス再定義)[スキルメモライズ併用] #-------------------------------------------------------------------------- alias k_before_skill_memorize3_change_equip change_equip unless $! def change_equip(slot_id, item) k_before_skill_memorize3_change_equip(slot_id, item) fix_memorize unless $kure_integrate_script[:integrate] end #-------------------------------------------------------------------------- # ◎ 職業の変更(エイリアス再定義) #-------------------------------------------------------------------------- alias k_before_skill_memorize3_change_class change_class unless $! def change_class(class_id, keep_exp = false) k_before_skill_memorize3_change_class(class_id, keep_exp) fix_memorize unless $kure_integrate_script[:multiclass] end #-------------------------------------------------------------------------- # ◎ スキルの初期化(エイリアス再定義) #-------------------------------------------------------------------------- alias k_before_skill_memorize3_init_skills init_skills unless $! def init_skills set_up_memorize k_before_skill_memorize3_init_skills if actor.first_memorize != [] @memory_skills = [] actor.first_memorize.each{|id| memorize_skill($data_skills[id].stype_id, nil, $data_skills[id], true)} end end #-------------------------------------------------------------------------- # ◎ スキルオブジェクトの配列取得(エイリアス再定義) #-------------------------------------------------------------------------- alias k_before_skill_memorize3_skills skills unless $! def skills if KURE::SkillMemorize3::ADOPT_MEMORIZE == 1 && !$game_party.in_battle k_before_skill_memorize3_skills else (memorize_skills | uniq_skills | extra_skills |added_skills).sort.collect {|id| $data_skills[id]} end end #-------------------------------------------------------------------------- # ◎ スキルを覚える(エイリアス再定義) #-------------------------------------------------------------------------- alias k_before_skill_memorize3_learn_skill learn_skill unless $! def learn_skill(skill_id) k_before_skill_memorize3_learn_skill(skill_id) if KURE::SkillMemorize3::AUTO_MEMORIZE == 1 && !KURE::SkillMemorize3::NOT_AUTO_MEMORIZE.include?($data_skills[skill_id].stype_id) && !$data_skills[skill_id].uniq_skill? && !$data_skills[skill_id].not_auto_memorize memorize_skill($data_skills[skill_id].stype_id, nil, $data_skills[skill_id], true) fix_memorize end end #-------------------------------------------------------------------------- # ◎ スキルを忘れる(エイリアス再定義) #-------------------------------------------------------------------------- alias k_before_skill_memorize3_forget_skill forget_skill unless $! def forget_skill(skill_id) k_before_skill_memorize3_forget_skill(skill_id) @memory_skills.each_with_index{|block, index| next unless block @memory_skills[index].delete(skill_id)} fix_memorize end #-------------------------------------------------------------------------- # ★ 習得しているスキルオブジェクトの配列取得(追加定義) #-------------------------------------------------------------------------- def learn_skills @skills.sort.collect {|id| $data_skills[id] } end #-------------------------------------------------------------------------- # ★ メモライズされているか判定(追加定義) #-------------------------------------------------------------------------- def memorized?(skill) return false unless skill return memorize_skills.include?(skill.id) end #-------------------------------------------------------------------------- # ★ メモライズオブジェクトのセットアップ(追加定義) #-------------------------------------------------------------------------- def set_up_memorize @memory_skills ||= [] ; @extra_skills ||= [] ; @memorize_obj ||= [] @element_shift ||= [] end #-------------------------------------------------------------------------- # ★ メモライズオブジェクトのクリア(追加定義) #-------------------------------------------------------------------------- def clear_memorize @memory_skills = [] ; @extra_skills = [] ; @element_shift ||= [] end #-------------------------------------------------------------------------- # ★ メモライズオブジェクトの呼び出し(追加定義) #-------------------------------------------------------------------------- def memorize_skills set_up_memorize return @memory_skills.flatten.compact end #-------------------------------------------------------------------------- # ★ 固有スキルオブジェクトの呼び出し(追加定義) #-------------------------------------------------------------------------- def uniq_skills @skills.select{|id| $data_skills[id].uniq_skill?} end #-------------------------------------------------------------------------- # ★ エクストラメモライズオブジェクトの呼び出し(追加定義) #-------------------------------------------------------------------------- def extra_skills set_up_memorize return @extra_skills end #-------------------------------------------------------------------------- # ★ 指定スキルタイプへメモライズを行う(追加定義) #-------------------------------------------------------------------------- def memorize_skill(s_type, slot, skill, limit = false) s_type = 0 if KURE::SkillMemorize3::USE_TYPE_0 == 1 && KURE::SkillMemorize3::TYPE_0_INCLUDE.include?(s_type) return unless KURE::SkillMemorize3::MEM_SETTING[s_type] return if memorized?(skill) @memory_skills[s_type] ||= [] if !skill && slot @memory_skills[s_type][slot] = nil ; set_extra_skills ; return end return if skill && skill.uniq_skill? if limit return unless skill_learn?(skill) return if memorize_num(s_type) >= max_memorize_num(s_type) \ && KURE::SkillMemorize3::MEM_SETTING[s_type][2] == 1 return if memorize_cap(s_type) + skill.memorize_capacity > max_memorize_cap(s_type) \ && KURE::SkillMemorize3::MEM_SETTING[s_type][3] == 1 @memory_skills[s_type].each{|id| next unless id ; return if skill.not_coexist.include?(id)} end unless slot @memory_skills[s_type].each_with_index{|id, index| next if id ; slot == index ; break} slot = @memory_skills[s_type].size unless slot end @memory_skills[s_type][slot] = skill.id if skill set_extra_skills set_passive_object if $kure_integrate_script[:integrate] end #-------------------------------------------------------------------------- # ★ エクストラメモライズのセット(追加定義) #-------------------------------------------------------------------------- def set_extra_skills @extra_skills = [] #チェインメモライズ list = KURE::SkillMemorize3::CHAIN_MEMORIZE list.each{|block| next unless block unit = block[1..block.size - 1] @extra_skills.push(block[0]) if (unit - memorize_skills).empty?} #エレメントメモライズ @element_shift = [] memorize_skills.each{|skill_id| $data_skills[skill_id].element_value.each{|block| @element_shift[block[0]] ||= 0 @element_shift[block[0]] += block[1] } } list2 = KURE::SkillMemorize3::ELEMENT_MEMORIZE list2.each{|block2| flag = 0 next unless block2 unit2 = block2[1..block2.size - 1] unit2.each{|cheak| unless @element_shift[cheak[0]] flag = 1 ; break end flag = 1 if @element_shift[cheak[0]] < cheak[1] break if flag == 1} @extra_skills.push(block2[0]) if flag == 0 } end #-------------------------------------------------------------------------- # ★ メモライズオブジェクトの修復補正(追加定義) #-------------------------------------------------------------------------- def fix_memorize @memory_skills.each_with_index{|block, type| next unless block while !memorize_cond_ok?(type) do @memory_skills[type].pop @memory_skills[type] ||= [] end block.each_with_index{|id, i| next unless id @memory_skills[type][i] = nil unless skill_learn?($data_skills[id]) } @memory_skills[type].compact! } set_extra_skills set_passive_object if $kure_integrate_script[:integrate] end #-------------------------------------------------------------------------- # ★ 指定IDのスキルタイプのメモライズ容量と数が正常化判定(追加定義) #-------------------------------------------------------------------------- def memorize_cond_ok?(id) if memorize_cap(id) > max_memorize_cap(id) && max_memorize_cap(id) > 0 return false if KURE::SkillMemorize3::MEM_SETTING[id][3] == 1 end if memorize_num(id) > max_memorize_num(id) && max_memorize_num(id) > 0 return false if KURE::SkillMemorize3::MEM_SETTING[id][2] == 1 end return true end #-------------------------------------------------------------------------- # ★ アクター毎の記憶関連変数を取得(追加定義) # 　　(type　0:メモライズ数　1:メモライズ容量)　 #-------------------------------------------------------------------------- def memorize_object(type ,id) @memorize_obj[type] ||= [] return @memorize_obj[type][id] ? @memorize_obj[type][id] : 0 end #-------------------------------------------------------------------------- # ★ アクター毎の記憶関連変数を操作(追加定義) # 　　(type　0:メモライズ数　1:メモライズ容量)　 #-------------------------------------------------------------------------- def set_memorize_object(type ,id, value) @memorize_obj[type] ||= [] @memorize_obj[type][id] ||= 0 @memorize_obj[type][id] += value end #-------------------------------------------------------------------------- # ★ スキルタイプごとのメモライズのIDリストを取得(追加定義) #-------------------------------------------------------------------------- def memorize_type_skill(s_type) @memory_skills[s_type] ||= [] return @memory_skills[s_type] end #-------------------------------------------------------------------------- # ★ 指定IDのスキルタイプのメモライズ数を取得(追加定義) #-------------------------------------------------------------------------- def memorize_num(id) return memorize_type_skill(id).compact.size end #-------------------------------------------------------------------------- # ★ 指定IDのスキルタイプのメモライズ容量を取得(追加定義) #-------------------------------------------------------------------------- def memorize_cap(id) memorize_type_skill(id).compact.inject(0) {|r, i| r += $data_skills[i].memorize_capacity } end #-------------------------------------------------------------------------- # ★ 指定IDのスキルタイプの最大メモライズ数を取得(追加定義) #-------------------------------------------------------------------------- def max_memorize_num(id) result = memorize_object(0 ,id) if $kure_integrate_script[:integrate] result += actor.gain_memorize_num(passive_note, id) else result += gain_max_mem_num(id) result += actor.gain_memorize_num(actor.note, id) result += $data_classes[@class_id].gain_memorize_num($data_classes[@class_id].note, id) end result = setting_data(id, 4, result) return result.to_i end #-------------------------------------------------------------------------- # ★ 指定IDのスキルタイプの最大メモライズ容量を取得(追加定義) #-------------------------------------------------------------------------- def max_memorize_cap(id) result = memorize_object(1 ,id) if $kure_integrate_script[:integrate] result += actor.gain_memorize_capacity(passive_note, id) else result += gain_max_mem_cap(id) result += actor.gain_memorize_capacity(actor.note, id) result += $data_classes[@class_id].gain_memorize_capacity($data_classes[@class_id].note , id) end result = setting_data(id, 5, result) return result.to_i end #-------------------------------------------------------------------------- # ★ 設定データを取得(追加定義) #-------------------------------------------------------------------------- def setting_data(id, data_id, base) return base unless KURE::SkillMemorize3::MEM_SETTING[id] return base unless KURE::SkillMemorize3::MEM_SETTING[id][data_id] base += KURE::SkillMemorize3::MEM_SETTING[id][data_id][0] base += KURE::SkillMemorize3::MEM_SETTING[id][data_id][1] * (@level - 1) return base if KURE::SkillMemorize3::MEM_SETTING[id][data_id][2] == 0 base = [base, KURE::SkillMemorize3::MEM_SETTING[id][data_id][2]].min return base end #-------------------------------------------------------------------------- # ★ 装備品の最大メモライズ容量補正を取得(追加定義) #-------------------------------------------------------------------------- def gain_max_mem_cap(id) equips.compact.inject(0) {|r, item| r += item.gain_memorize_capacity(item.note, id) } end #-------------------------------------------------------------------------- # ★ 装備品の最大メモライズ数補正を取得(追加定義) #-------------------------------------------------------------------------- def gain_max_mem_num(id) equips.compact.inject(0) {|r, item| r += item.gain_memorize_num(item.note , id) } end end #============================================================================== # ■ Scene_SkillMemorize3 #============================================================================== class Scene_SkillMemorize3 < Scene_MenuBase #-------------------------------------------------------------------------- # ● 開始処理 #-------------------------------------------------------------------------- def start super @actor.set_up_memorize @actor.fix_memorize create_help_window create_status_window create_command_window create_memorize_window create_select_window create_pop_window setup_window end #-------------------------------------------------------------------------- # ● ステータスウィンドウの作成 #-------------------------------------------------------------------------- def create_status_window wx = 0 ; wy = @help_window.height ; ww = Graphics.width ; wh = 120 @status_window = Window_k_SkillMemorize_SkillStatus.new(wx,wy,ww,wh) end #-------------------------------------------------------------------------- # ● コマンドウィンドウの作成 #-------------------------------------------------------------------------- def create_command_window wx = (Graphics.width / 2) - 30 wy = @help_window.height @command_window = Window_k_Skillmemorize_SkillCommand.new(wx, wy) @command_window.set_handler(:ok, method(:command_skill)) @command_window.set_handler(:cancel, method(:return_scene)) @command_window.set_handler(:pagedown, method(:next_actor)) @command_window.set_handler(:pageup, method(:prev_actor)) @command_window.opacity = 0 @command_window.activate end #-------------------------------------------------------------------------- # ● メモライズウィンドウの作成 #-------------------------------------------------------------------------- def create_memorize_window wx = 0 wy = @help_window.height + @status_window.height ww = Graphics.width / 2 wh = Graphics.height - wy @memorize_window = Window_k_SkillMemorize_SkillList.new(wx, wy, ww, wh) @memorize_window.set_handler(:ok, method(:on_memorize_ok)) @memorize_window.set_handler(:cancel, method(:on_memorize_cancel)) @memorize_window.help_window = @help_window @memorize_window.unselect @memorize_window.deactivate end #-------------------------------------------------------------------------- # ● セレクトウィンドウの作成 #-------------------------------------------------------------------------- def create_select_window wx = @memorize_window.width wy = @help_window.height + @status_window.height ww = Graphics.width / 2 wh = Graphics.height - wy @select_window = Window_k_SkillMemorize_LearnList.new(wx, wy, ww, wh) @select_window.set_handler(:ok, method(:on_select_ok)) @select_window.set_handler(:cancel, method(:on_select_cancel)) @select_window.help_window = @help_window @select_window.unselect @select_window.deactivate end #-------------------------------------------------------------------------- # ● ポップアップウィンドウの作成 #-------------------------------------------------------------------------- def create_pop_window wx = 50 wy = 50 ww = Graphics.width - (wx * 2) wh = Graphics.height - (wy * 2) @pop_window = Window_k_SkillMemorize_PopUp.new(wx, wy, ww, wh) @pop_window.z += 100 @pop_window.back_opacity = 255 @pop_window.hide end #-------------------------------------------------------------------------- # ● コマンドウィンドウ[決定] #-------------------------------------------------------------------------- def command_skill @command_window.deactivate @memorize_window.select(0) @memorize_window.activate end #-------------------------------------------------------------------------- # ● コマンドウィンドウ[キャンセル] #-------------------------------------------------------------------------- def return_scene @actor.set_passive_object if $kure_integrate_script[:integrate] SceneManager.return end #-------------------------------------------------------------------------- # ● コマンドウィンドウ[切り替え] #-------------------------------------------------------------------------- def next_actor @actor.set_passive_object if $kure_integrate_script[:integrate] @actor = $game_party.menu_actor_next on_actor_change end #-------------------------------------------------------------------------- # ● コマンドウィンドウ[切り替え] #-------------------------------------------------------------------------- def prev_actor @actor.set_passive_object if $kure_integrate_script[:integrate] @actor = $game_party.menu_actor_prev on_actor_change end #-------------------------------------------------------------------------- # ● 記憶ウィンドウ［決定］ #-------------------------------------------------------------------------- def on_memorize_ok if @pop_window.visible @pop_window.hide ; @memorize_window.activate ; return end @memorize_window.deactivate @select_window.select(0) @select_window.activate @pop_window.old_skills = @actor.extra_skills @pop_window.old_memorize = @actor.memorize_skills end #-------------------------------------------------------------------------- # ● 記憶ウィンドウ［キャンセル］ #-------------------------------------------------------------------------- def on_memorize_cancel if @pop_window.visible @pop_window.hide ; @memorize_window.activate ; return end @memorize_window.unselect @memorize_window.deactivate @command_window.activate @command_window.select(0) @help_window.set_text("スキルタイプを選択してください") end #-------------------------------------------------------------------------- # ● セレクトウィンドウ［決定］ #-------------------------------------------------------------------------- def on_select_ok s_type = @select_window.stype_id slot = @memorize_window.index skill = @select_window.current_ext @actor.memorize_skill(s_type, slot, skill) @actor.fix_memorize @select_window.refresh @memorize_window.refresh @command_window.refresh on_select_cancel @pop_window.new_skills = @actor.extra_skills return if @pop_window.new_skills == @pop_window.old_skills @pop_window.refresh Audio.se_play("Audio/SE/Chime2") @pop_window.show end #-------------------------------------------------------------------------- # ● セレクトウィンドウ［キャンセル］ #-------------------------------------------------------------------------- def on_select_cancel @select_window.unselect @select_window.deactivate @memorize_window.activate end #-------------------------------------------------------------------------- # ● アクターの切り替え #-------------------------------------------------------------------------- def on_actor_change @actor.set_up_memorize @actor.fix_memorize setup_window @command_window.activate end #-------------------------------------------------------------------------- # ● ウィンドウのセットアップ #-------------------------------------------------------------------------- def setup_window @help_window.set_text("スキルタイプを選択してください") @command_window.memorize_window = @memorize_window @command_window.select_window = @select_window @memorize_window.select_window = @select_window @status_window.actor = @actor @command_window.actor = @actor @memorize_window.actor = @actor @select_window.actor = @actor @pop_window.actor = @actor @memorize_window.pop_window = @pop_window @command_window.select(0) end end #============================================================================== # ■ Window_Base #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # ● 記憶容量の描画 #-------------------------------------------------------------------------- def draw_memorize_gauge(x, y, actor, type) mem = actor.memorize_cap(type) max = actor.max_memorize_cap(type) rate = max != 0 ? mem.to_f / max : 0 if KURE::SkillMemorize3::MEM_SETTING[type][3] == 0 rate = 0 ; max = "∞" end draw_gauge(x, y, 124, rate, tp_gauge_color1, tp_gauge_color2) change_color(system_color) draw_text(x, y, 30, line_height, KURE::SkillMemorize3::MEM_CAP_NAME) draw_current_and_max_values(x, y, 124, mem, max, mp_color(actor), normal_color) end end #============================================================================== # ■ Window_k_SkillMemorize_SkillStatus #============================================================================== class Window_k_SkillMemorize_SkillStatus < Window_Base #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- def initialize(x, y, ww, wh) super(x, y, ww, wh) @actor = nil end #-------------------------------------------------------------------------- # ● アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) return if @actor == actor @actor = actor refresh end #-------------------------------------------------------------------------- # ● リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear return unless @actor draw_actor_face(@actor, 0, 0) draw_actor_name(@actor, 108, 0) draw_actor_level(@actor, 108, line_height * 1) draw_actor_class(@actor, 108, line_height * 2) end end #============================================================================== # ■ Window_k_Skillmemorize_SkillCommand(新規) #============================================================================== class Window_k_Skillmemorize_SkillCommand < Window_Command attr_accessor :actor attr_accessor :memorize_window attr_accessor :select_window #-------------------------------------------------------------------------- # ● 表示行数の取得 #-------------------------------------------------------------------------- def visible_line_number ; 4 ; end #-------------------------------------------------------------------------- # ● ウィンドウ幅の取得 #-------------------------------------------------------------------------- def window_width return (Graphics.width / 2) + 30 end #-------------------------------------------------------------------------- # ● アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) return if @actor == actor @actor = actor refresh end #-------------------------------------------------------------------------- # ● カーソル位置の設定 #-------------------------------------------------------------------------- def index=(index) @index = index update_cursor call_update_help @memorize_window.stype_id = current_ext if @memorize_window @select_window.stype_id = current_ext if @select_window end #-------------------------------------------------------------------------- # ● 全項目の描画 #-------------------------------------------------------------------------- def draw_all_items item_max.times {|i| draw_item(i) ; draw_actor_memorize(i)} end #-------------------------------------------------------------------------- # ● コマンドリストの作成 #-------------------------------------------------------------------------- def make_command_list return unless @actor add_command(KURE::SkillMemorize3::TYPE_0_NAME, :ok, true, 0) if KURE::SkillMemorize3::USE_TYPE_0 == 1 @actor.added_skill_types.sort.each{|stype_id| next if KURE::SkillMemorize3::MEM_SETTING[stype_id] && KURE::SkillMemorize3::MEM_SETTING[stype_id][1] == 0 name = $data_system.skill_types[stype_id] add_command(name, :ok, true, stype_id)} end #-------------------------------------------------------------------------- # ● 記憶容量の描画 #-------------------------------------------------------------------------- def draw_actor_memorize(index) return unless @actor type = @list[index][:ext] return unless KURE::SkillMemorize3::MEM_SETTING[type] return if KURE::SkillMemorize3::MEM_SETTING[type][0] == 0 x = 130 ; y = item_rect_for_text(index).y draw_memorize_gauge(x, y, @actor, type) end end #============================================================================== # ■ Window_k_SkillMemorize_SkillList(新規) #============================================================================== class Window_k_SkillMemorize_SkillList < Window_Command attr_accessor :select_window attr_accessor :pop_window #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- def initialize(x, y, width, height) @stype_id = 0 @width = width @height = height super(x, y) end #-------------------------------------------------------------------------- # ● ウィンドウ幅の取得 #-------------------------------------------------------------------------- def window_width return @width end #-------------------------------------------------------------------------- # ● ウィンドウ高さの取得 #-------------------------------------------------------------------------- def window_height return @height end #-------------------------------------------------------------------------- # ● アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) return if @actor == actor @actor = actor refresh end #-------------------------------------------------------------------------- # ● スキルタイプ ID の設定 #-------------------------------------------------------------------------- def stype_id=(stype_id) return if @stype_id == stype_id @stype_id = stype_id refresh end #-------------------------------------------------------------------------- # ● カーソル位置の設定 #-------------------------------------------------------------------------- def index=(index) @index = index update_cursor call_update_help @select_window.select_obj = item if @select_window @pop_window.hide if @pop_window end #-------------------------------------------------------------------------- # ● カーソルを右に移動 #-------------------------------------------------------------------------- def cursor_right(wrap = false) @pop_window.hide if @pop_window end #-------------------------------------------------------------------------- # ● カーソルを左に移動 #-------------------------------------------------------------------------- def cursor_left(wrap = false) @pop_window.hide if @pop_window end #-------------------------------------------------------------------------- # ● スキルの取得 #-------------------------------------------------------------------------- def item @data && index >= 0 ? @data[index] : nil end #-------------------------------------------------------------------------- # ● ヘルプテキスト更新 #-------------------------------------------------------------------------- def update_help @help_window.set_item(item) end #-------------------------------------------------------------------------- # ● 全項目の描画 #-------------------------------------------------------------------------- def draw_all_items return unless @actor item_max.times {|i| draw_item(i) ; draw_number(i)} end #-------------------------------------------------------------------------- # ● 番号の描画 #-------------------------------------------------------------------------- def draw_number(index) draw_text(0, line_height * index, 24, line_height, index + 1, 2) end #-------------------------------------------------------------------------- # ● 項目の描画 #-------------------------------------------------------------------------- def draw_item(index) skill = @data[index] return unless skill rect = item_rect(index) rect.width -= 4 draw_item_name(skill, rect.x + 30, rect.y) return if skill.memorize_capacity == 0 change_color(power_down_color) draw_text(rect.width - 30, line_height * index, 30, line_height, skill.memorize_capacity, 2) change_color(normal_color) end #-------------------------------------------------------------------------- # ● 項目を描画する矩形の取得（テキスト用） #-------------------------------------------------------------------------- def item_rect_for_text(index) rect = item_rect(index) rect.x += 54 rect.width -= 8 rect end #-------------------------------------------------------------------------- # ● コマンドリストの作成 #-------------------------------------------------------------------------- def make_command_list return unless @actor return unless KURE::SkillMemorize3::MEM_SETTING[@stype_id] @data = @actor.memorize_type_skill(@stype_id).collect{|id| id ? $data_skills[id] : nil} if KURE::SkillMemorize3::MEM_SETTING[@stype_id][2] == 0 num = @actor.memorize_num(@stype_id) + 1 else num = @actor.max_memorize_num(@stype_id) end num.times{|i| if @data[i] != nil add_command(@data[i].name, :ok, true , @data[i].memorize_capacity) else add_command("", :ok) end } end end #============================================================================== # ■ Window_k_SkillMemorize_LearnList(新規) #============================================================================== class Window_k_SkillMemorize_LearnList < Window_Command attr_reader :stype_id #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- def initialize(x, y, width, height) @stype_id = 0 @width = width @height = height @page_index = 0 @page_max = 0 @first = 0 @last = 0 @select_obj = nil super(x, y) end #-------------------------------------------------------------------------- # ● ウィンドウ幅の取得 #-------------------------------------------------------------------------- def window_width return @width end #-------------------------------------------------------------------------- # ● ウィンドウ高さの取得 #-------------------------------------------------------------------------- def window_height return @height end #-------------------------------------------------------------------------- # ● アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) return if @actor == actor @actor = actor refresh end #-------------------------------------------------------------------------- # ● スキルタイプ ID の設定 #-------------------------------------------------------------------------- def stype_id=(stype_id) return if @stype_id == stype_id @stype_id = stype_id @page_index = 0 refresh end #-------------------------------------------------------------------------- # ● オブジェクトの設定 #-------------------------------------------------------------------------- def select_obj=(select_obj) return if @select_obj == select_obj @select_obj = select_obj refresh end #-------------------------------------------------------------------------- # ● カーソルを右に移動 #-------------------------------------------------------------------------- def cursor_right(wrap = false) @page_index += 1 refresh end #-------------------------------------------------------------------------- # ● カーソルを左に移動 #-------------------------------------------------------------------------- def cursor_left(wrap = false) @page_index -= 1 refresh end #-------------------------------------------------------------------------- # ● ヘルプテキスト更新 #-------------------------------------------------------------------------- def update_help @help_window.set_item(current_ext) end #-------------------------------------------------------------------------- # ● 全項目の描画 #-------------------------------------------------------------------------- def draw_all_items return unless @actor item_max.times {|i| draw_item(i)} end #-------------------------------------------------------------------------- # ● 項目の描画 #-------------------------------------------------------------------------- def draw_item(index) skill = @data[index] if skill == nil draw_text(item_rect_for_text(index), command_name(index), alignment) return end rect = item_rect(index) rect.width -= 4 draw_item_name(skill, rect.x, rect.y, command_enabled?(index)) change_color(normal_color) return if skill.memorize_capacity == 0 change_color(power_down_color) draw_text(rect.width - 30, line_height * index, 30, line_height, skill.memorize_capacity, 2) change_color(normal_color) end #-------------------------------------------------------------------------- # ● コマンドリストの作成 #-------------------------------------------------------------------------- def make_command_list return unless @actor @data = @actor.learn_skills.select{|skill| include?(skill)} @page_max = @data.size.div(6) @page_max = [@page_max - 1, 0].max if @data.size.modulo(6) == 0 @page_index = 0 if @page_index > @page_max @page_index = @page_max if @page_index < 0 @first = 6 * @page_index @last = [5 + 6 * @page_index, @data.size].min @data = @data[@first..@last] mem = @actor.memorize_cap(@stype_id) max = @actor.max_memorize_cap(@stype_id) @data.each{|skill| add_command(skill.name, :ok, can_memorize?(skill, mem, max), skill)} add_command("　　メモライズ解除", :ok, true, nil) end #-------------------------------------------------------------------------- # ● 項目を加えるか #-------------------------------------------------------------------------- def include?(skill) return false unless skill return false if skill.uniq_skill? return false if @actor.memorized?(skill) if @stype_id == 0 && KURE::SkillMemorize3::USE_TYPE_0 == 1 return true if KURE::SkillMemorize3::TYPE_0_INCLUDE.include?(skill.stype_id) return false unless $kure_integrate_script[:integrate] skill.add_skill_type.each{|id| return true if KURE::SkillMemorize3::TYPE_0_INCLUDE.include?(id)} else return true if skill.stype_id == @stype_id return false unless $kure_integrate_script[:integrate] return true if skill.add_skill_type.include?(@stype_id) end return false end #-------------------------------------------------------------------------- # ● メモライズできるか #-------------------------------------------------------------------------- def can_memorize?(skill, mem, max) list = @actor.memorize_type_skill(@stype_id).clone list.delete(@select_obj.id) if @select_obj list.each{|id| next unless id ; return false if skill.not_coexist.include?(id)} return true if KURE::SkillMemorize3::MEM_SETTING[@stype_id][3] == 0 data1 = skill ? skill.memorize_capacity : 0 data2 = @select_obj ? @select_obj.memorize_capacity : 0 value = data1 - data2 return true if max >= mem + value return false end #-------------------------------------------------------------------------- # ● ページ表示 #-------------------------------------------------------------------------- def draw_guide last_font = contents.font.size contents.font.size = 20 draw_text(0, contents.height - contents.font.size, contents.width, contents.font.size, "← →:表示切替( " + (@page_index + 1).to_s + " / " + (@page_max + 1).to_s + " )" ,1) contents.font.size = last_font end #-------------------------------------------------------------------------- # ● リフレッシュ #-------------------------------------------------------------------------- def refresh clear_command_list make_command_list create_contents super draw_guide end end #============================================================================== # ■ Window_k_SkillMemorize_PopUp #============================================================================== class Window_k_SkillMemorize_PopUp < Window_Base attr_accessor :old_skills attr_accessor :old_memorize attr_accessor :new_skills #-------------------------------------------------------------------------- # ● オブジェクト初期化 #-------------------------------------------------------------------------- def initialize(x, y, ww, wh) super(x, y, ww, wh) @actor = nil @old_skills = [] @old_memorize = [] @new_skills = [] end #-------------------------------------------------------------------------- # ● アクターの設定 #-------------------------------------------------------------------------- def actor=(actor) return if @actor == actor @actor = actor refresh end #-------------------------------------------------------------------------- # ● リフレッシュ #-------------------------------------------------------------------------- def refresh contents.clear return unless @actor add_skills = @new_skills - @old_skills delete_skills = @old_skills - @new_skills line = 0 ; count = 0 if add_skills != [] draw_gauge(5, line * line_height, contents.width, 1, mp_gauge_color2,crisis_color) draw_text(5, line * line_height, contents.width, line_height, "追加メモライズ") line += 1 add_skills.each_with_index{|id, index| icon_pos = 0 draw_item_name($data_skills[id], 0, (index + line) * line_height) cond_skills = KURE::SkillMemorize3::CHAIN_MEMORIZE.find{|block| block[0] == id && (block[1..block.size - 1] - @actor.memorize_skills).empty?} if cond_skills cond_skills[1..cond_skills.size - 1].each{|id| draw_icon($data_skills[id].icon_index, 180 + icon_pos * 30, (index + line) * line_height) icon_pos += 1} end count += 1 } end line = line + count if delete_skills != [] draw_gauge(5, line * line_height, contents.width, 1, mp_gauge_color2,crisis_color) draw_text(5, line * line_height, contents.width, line_height, "削除メモライズ") line += 1 delete_skills.each_with_index{|id, index| icon_pos = 0 draw_item_name($data_skills[id], 0, (index + line) * line_height) cond_skills = KURE::SkillMemorize3::CHAIN_MEMORIZE.find{|block| block[0] == id && (block[1..block.size - 1] - @old_memorize).empty?} if cond_skills cond_skills[1..cond_skills.size - 1].each{|id| draw_icon($data_skills[id].icon_index, 180 + icon_pos * 30, (index + line) * line_height) icon_pos += 1} end } end end end #============================================================================== # ■ Game_Interpreter(追加定義) #============================================================================== class Game_Interpreter #-------------------------------------------------------------------------- # ● メモライズの追加(追加定義) #-------------------------------------------------------------------------- def add_memorize(actor_id, skill_id, limit) actor = $game_actors[actor_id] actor.memorize_skill($data_skills[skill_id].stype_id, nil, $data_skills[skill_id], limit) end #-------------------------------------------------------------------------- # ● メモライズの初期化(追加定義) #-------------------------------------------------------------------------- def clear_memorize(actor_id) actor = $game_actors[actor_id] actor.clear_memorize end #-------------------------------------------------------------------------- # ● メモライズ数、容量の変化(追加定義) #-------------------------------------------------------------------------- def add_memorize_obj(actor_id, mode, stype, value) actor = $game_actors[actor_id] actor.set_memorize_object(mode , stype, value) end #-------------------------------------------------------------------------- # ● メモライズ判定(追加定義) #-------------------------------------------------------------------------- def cheak_memorize(actor_id, skill_id) actor = $game_actors[actor_id] return actor.memorized?($data_skills[skill_id]) end end