#============================================================================== # ■統合ベーススクリプトＢ for RGSS3 Ver2.21-β #　□作成者 kure # #　メモ欄の取得および共通処理モジュールに関するスクリプト群です。 # #============================================================================== p "統合ベーススクリプトＢ" #メモ欄の取得に関するスクリプト処理群------------------------------------------- module KURE #-------------------------------------------------------------------------- # ☆ 拡張特徴呼び出し(追加定義) #-------------------------------------------------------------------------- def self.call_add_feature(id, note_data = "") result = [] case id #ステータス増加(加算処理) when 0 ; result = add_feature_basic([], note_data, "能力値変化", 23, 11) #属性強化(乗算処理) when 1 ; result = add_feature_basic([], note_data, "属性強化", 20, 12) #属性追加(加算処理) when 2 ; result = add_feature_basic([], note_data, "属性追加", 22, 12) #属性耐性(加算処理) when 3 ; result = add_feature_basic([], note_data, "属性耐性", 22, 12) #命中強化(乗算処理) when 4 ; result = add_feature_basic([], note_data, "命中タイプ強化", 20, 12) #命中強化(加算処理) when 5 ; result = add_feature_basic([], note_data, "命中タイプ追加", 22, 12) #命中耐性(加算処理) when 6 ; result = add_feature_basic([], note_data, "命中タイプ耐性", 22, 12) #通常攻撃強化(乗算処理) when 7 ; result = add_feature_basic(1, note_data, "通常攻撃強化", 10, 2) #通常攻撃耐性(加算処理) when 8 ; result = add_feature_basic(0, note_data, "通常攻撃耐性", 12, 2) #スキルタイプ強化(乗算処理) when 9 ; result = add_feature_basic([], note_data, "スキルタイプ強化", 20, 12) #スキルタイプ耐性(加算処理) when 10 ; result = add_feature_basic([], note_data, "スキルタイプ耐性", 22, 12) #ステート強化(乗算処理) when 11 ; result = add_feature_basic([], note_data, "ステート強化", 20, 12) #ステート追加(加算処理) when 12 ; result = add_feature_basic([], note_data, "ステート追加", 22, 12) #ステート耐性(加算処理) when 13 ; result = add_feature_basic([], note_data, "ステート耐性", 22, 12) #武器タイプ強化(乗算処理) when 14 ; result = add_feature_basic([], note_data, "武器タイプ強化", 20, 12) #回復強化(乗算処理) when 15 ; result = add_feature_basic([], note_data, "回復強化", 20, 12) #回復追加(乗算処理) when 16 ; result = add_feature_basic([], note_data, "回復追加", 22, 12) #回復反転(加算処理) when 17 ; result = add_feature_basic([], note_data, "回復弱化", 22, 12) #会心強化(乗算処理) when 18 ; result = add_feature_basic(1, note_data, "会心強化", 10, 2) #会心強化(乗算処理) when 19 ; result = add_feature_basic(1, note_data, "会心有効度", 14, 2) #会心耐性(加算処理) when 20 ; result = add_feature_basic(0, note_data, "会心追加", 12, 2) #会心耐性(加算処理) when 21 ; result = add_feature_basic(0, note_data, "会心耐性", 12, 2) #逆境補正(加算処理) when 22 ; result = add_feature_basic([0,0,0], note_data, "逆境補正", 34, 222) #ダメージ上限(最小値処理) when 23 ; result = add_feature_basic(0, note_data, "ダメージ上限", 13, 1) #ダメージ無効化(配列取得) when 24 ; result = add_feature_basic([], note_data, "ダメージ無効化", 21, 11) #命中タイプ無効化(配列取得) when 25 ; result = add_feature_basic([], note_data, "命中タイプ無効化", 41, 1121) #ダメージ減少(配列取得) when 26 ; result = add_feature_basic([], note_data, "ダメージ減少", 41, 1221) #踏みとどまり(配列取得) when 27 ; result = add_feature_basic([], note_data, "踏みとどまり", 31, 221) #オートステート(配列取得) when 28 ; result= arr_num_slice(note_data.scan(/<オートステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) #完全オートステート(配列取得) when 29 ; result= arr_num_slice(note_data.scan(/<完全オートステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) #通常反撃(加算処理) when 30 ; result = add_feature_basic([[],[],[],[]], note_data, "通常反撃", 30, 112) #優先対象(配列処理) when 31 ; result = add_feature_basic([], note_data, "優先対象", 18, 1) #ダメージ変換(配列取得) when 32 ; result = add_feature_basic([], note_data, "ダメージ変換", 41, 1221) #ダメージ回収(配列取得) when 33 ; result = add_feature_basic([], note_data, "ダメージ回収", 41, 1221) #反撃スキル(配列取得) when 34 ; result = add_feature_basic([[],[],[],[]], note_data, "反撃スキル", 42, 1111) #反撃無効化(配列取得) when 35 ; result = add_feature_basic([], note_data, "反撃無効化", 31, 121) #反撃強化(乗算処理) when 36 ; result = add_feature_basic(1, note_data, "反撃強化", 10, 2) #反撃耐性(加算処理) when 37 ; result = add_feature_basic(0, note_data, "反撃耐性", 12, 2) #拡張反撃(加算処理) when 38 ; result = add_feature_basic([[],[],[],[]], note_data, "拡張反撃", 30, 112) #回避反撃(加算処理) when 39 ; result = add_feature_basic([[],[],[],[]], note_data, "回避反撃", 30, 112) #反撃ステート(加算処理) when 40 ; result = add_feature_basic([], note_data, "反撃ステート", 51, 11121) #反撃スキル(配列取得) when 41 ; result = add_feature_basic([[],[],[],[]], note_data, "最終反撃スキル", 32, 111) #身代わり反撃(加算処理) when 42 ; result = add_feature_basic([[],[],[],[]], note_data, "身代わり反撃", 30, 112) #スキル変化(配列取得) when 43 ; result = add_feature_basic([], note_data, "スキル変化", 41, 1121) #スキル変化(配列取得) when 44 ; result = add_feature_basic([], note_data, "行動変化", 31, 121) #必中反射(加算処理) when 45 ; result = add_feature_basic(0, note_data, "必中反射", 12, 2) #物理反射(加算処理) when 46 ; result = add_feature_basic(0, note_data, "物理反射", 12, 2) #反射強化(乗算処理) when 47 ; result = add_feature_basic(1, note_data, "反射強化", 10, 2) #反射耐性(加算処理) when 48 ; result = add_feature_basic(0, note_data, "反射耐性", 12, 2) #反射無効化(配列取得) when 49 ; result = add_feature_basic([], note_data, "反射無効化", 31, 121) #ステート転換(配列取得) when 50 ; result = add_feature_basic([], note_data, "ステート転換", 41, 1121) #連続発動(配列取得) when 51 ; result = add_feature_basic([], note_data, "連続発動", 23, 11) #反撃ステート無効化(配列取得) when 52 ; result = add_feature_basic([], note_data, "反撃ステート無効化", 21, 21) #行動反応追撃(配列取得) when 53 ; result = add_feature_basic([], note_data, "行動反応追撃", 51, 11121) #戦闘後回復(配列取得) when 54 ; result = add_feature_basic([[0,0],[0,0]], note_data, "戦闘後回復", 35, 122) #特殊発動(配列取得) when 55 ; result = add_feature_basic([], note_data, "特殊発動", 41, 1121) #最大TP変化(加算処理) when 56 ; result = add_feature_basic([0,1], note_data, "最大TP変化", 25, 12) #TP消費率(乗算処理) when 57 ; result = add_feature_basic(1, note_data, "TP消費率", 14, 2) #HP消費率(乗算処理) when 58 ; result = add_feature_basic(1, note_data, "HP消費率", 14, 2) #タイプ消費率(乗算処理) when 59 ; result = add_feature_basic([[],[],[]], note_data, "タイプ消費率", 36, 112) #即死反転(配列取得) when 60 ; result = add_feature_basic([], note_data, "即死反転", 31, 221) #スティール率(乗算処理) when 61 ; result = add_feature_basic(1, note_data, "スティール率", 14, 2) #防御壁展開(配列取得) when 62 ; result = add_feature_basic([], note_data, "防御壁展開", 51, 11211) #追撃無効化(配列取得) when 63 ; result = add_feature_basic([], note_data, "追撃無効化", 31, 121) #自動復活(配列取得) when 64 ; result = add_feature_basic([], note_data, "自動復活", 52, 11221) #トリガーステート(配列取得) when 65 ; result = add_feature_basic([], note_data, "トリガーステート", 51, 11211) #ディレイステート(配列取得) when 66 ; result = add_feature_basic([], note_data, "ディレイステート", 31, 111) #特殊追撃(配列取得) when 67 ; result = add_feature_basic([], note_data, "特殊追撃", 41, 1121) #自爆耐性(配列取得) when 68 ; result = add_feature_basic([], note_data, "自爆耐性", 21, 21) #エンカウント率(乗算処理) when 69 ; result = add_feature_basic(1, note_data, "エンカウント率", 14, 2) #ドロップ率(乗算処理) when 70 ; result = add_feature_basic(1, note_data, "ドロップ率", 14, 2) #獲得金額率(乗算処理) when 71 ; result = add_feature_basic(1, note_data, "獲得金額率", 14, 2) #攻撃属性(配列取得) when 72 ; result = add_feature_basic([], note_data, "攻撃属性", 21, 11) #耐久値減少率(乗算処理) when 73 ; result = add_feature_basic(1, note_data, "耐久値減少率", 14, 2) #ドロップ率増加(乗算処理) when 74 ; result = add_feature_basic(1, note_data, "ドロップ率増加", 10, 2) #身代わり(最小値処理) when 75 ; result = add_feature_basic([-1,-1], note_data, "拡張身代わり", 27, 12) #属性場展開(配列取得) when 76 ; result = add_feature_basic([], note_data, "属性場展開", 21, 11) #効果範囲強化(乗算処理) when 77 ; result = add_feature_basic([], note_data, "効果範囲強化", 20, 12) #効果範囲強化(加算処理) when 78 ; result = add_feature_basic([], note_data, "効果範囲追加", 22, 12) #効果範囲耐性(加算処理) when 79 ; result = add_feature_basic([], note_data, "効果範囲耐性", 22, 12) #ドロップ率増加(乗算処理) when 80 ; result = add_feature_basic(1, note_data, "獲得額増加率", 10, 2) #ディレイ変化(単純加算) when 81 ; result = add_feature_basic(0, note_data, "ディレイ変化", 15, 1) #変数ステータス増加(加算処理) when 82 ; result = add_feature_basic([], note_data, "変数能力値変化", 24, 11) #AP制スキル習得能力(配列取得) when 83 ; result = add_feature_basic([], note_data, "APスキル習得", 21, 11) #属性反応ステート発動能力(配列取得) when 84 ; result = add_feature_basic([], note_data, "属性反応ステート", 31, 111) #魔法命中率(加算処理) when 85 ; result = add_feature_basic(1, note_data, "魔法命中率", 12, 2) #属性有効度指定(配列取得) when 86 ; result = add_feature_basic([], note_data, "有効度指定", 38, 112) #文章表示(配列取得) when 87 ; result = add_feature_basic([], note_data, "文章表示", 17, 3) #スキル強化(配列処理) when 88 ; result = add_feature_basic([], note_data, "スキル強化", 21, 12) #スキル耐性(配列処理) when 89 ; result = add_feature_basic([], note_data, "スキル耐性", 21, 12) #反動変化(配列加算処理) when 90 ; result = add_feature_basic([0,0,0], note_data, "反動変化", 37, 121) #タイプ消費率(乗算処理) when 91 ; result = add_feature_basic([[],[],[]], note_data, "タイプ消費変化", 33, 111) #属性消費率(乗算処理) when 92 ; result = add_feature_basic([[],[],[]], note_data, "属性消費率", 36, 112) #属性消費率(乗算処理) when 93 ; result = add_feature_basic([[],[],[]], note_data, "属性消費変化", 33, 111) #レベル上昇補正(配列処理) when 94 ; result = add_feature_basic([], note_data, "レベル上昇補正", 21, 11) #使用効果無効化(配列取得) when 95 ; result = add_feature_basic([[],[],[]], note_data, "使用効果無効化", 42, 1121) #スキル変換(配列取得) when 96 ; result = add_feature_basic([], note_data, "スキル変換", 51, 11121) #アイテム変換(配列取得) when 97 ; result = add_feature_basic([], note_data, "アイテム変換", 51, 11121) #命中タイプ変化(配列取得) when 98 ; result = add_feature_basic([[],[],[],[]], note_data, "命中タイプ指定", 130, 111) #ダメージ反射(加算処理) when 99 ; result = add_feature_basic([[],[],[],[]], note_data, "ダメージ反射", 30, 112) #ダメージ反射率(加算処理) when 100 ; result = add_feature_basic(1, note_data, "ダメージ反射有効度", 14, 2) #ダメージ反射強化(乗算処理) when 101 ; result = add_feature_basic(1, note_data, "ダメージ反射強化", 10, 2) #ダメージ反射追加(加算処理) when 102 ; result = add_feature_basic(0, note_data, "ダメージ反射追加", 12, 2) #ダメージ反射耐性(加算処理) when 103 ; result = add_feature_basic(0, note_data, "ダメージ反射耐性", 12, 2) #回復効果率無視(単純出力) when 104 ; result = add_feature_basic(0, note_data, "回復効果率無視", 16, 1) #分散度変化(単純加算) when 105 ; result = add_feature_basic(0, note_data, "分散度変化", 15, 1) #ステート有効度無視(単純出力) when 106 ; result = add_feature_basic(0, note_data, "ステート有効度無視", 16, 1) #優先対象(配列処理) when 107 ; result = add_feature_basic([], note_data, "貫通技能", 18, 1) end return result end #-------------------------------------------------------------------------- # ☆ メモ欄の読み込み基本処理(追加定義) #-------------------------------------------------------------------------- def self.add_feature_basic(base, note_data, word, task_id, read_id) value = base ; cheakword = word while note_data do case read_id when 1 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?>/) when 2 ; note_data.match(/<#{cheakword}\s?([-]?\d+)%\s?>/) when 3 ; note_data.match(/<#{cheakword}\s?(.+?)\s?>/) when 11 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 12 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?>/) when 21 ; note_data.match(/<#{cheakword}\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 22 ; note_data.match(/<#{cheakword}\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?>/) when 111 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 112 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?>/) when 121 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 122 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?>/) when 221 ; note_data.match(/<#{cheakword}\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 222 ; note_data.match(/<#{cheakword}\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?>/) when 1111 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 1121 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 1211 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 1221 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 11111 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 11121 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 11211 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) when 11221 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?>/) when 121111 ; note_data.match(/<#{cheakword}\s?([-]?\d+)\s?,\s?([-]?\d+)%\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?,\s?([-]?\d+)\s?>/) end case task_id when 10..19 if $1 case task_id #％増加の乗算処理(百分率処理)(項目数1) when 10 ; value *= (1 + ($1.to_f / 100)) #最大値処理(項目数1) when 11 ; value = [value, $1.to_i].max #加算処理(百分率処理)(項目数1) when 12 ; value += ($1.to_f / 100) #最小値処理(項目数1) when 13 ; value = (value == base) ? $1.to_i : [value, $1.to_i].min #１基準の乗算処理(百分率処理)(項目数1) when 14 ; value *= ($1.to_f / 100) #加算処理(単純加算) when 15 ; value += $1.to_i #単純代入 when 16 ; value = $1.to_i #文字列を配列に出力(項目数1) when 17 ; value.push($1) #値を配列に出力(項目数1) when 18 ; value.push($1.to_i) end end when 20..29 if $1 && $2 case task_id #IDへ乗算処理(項目数2) when 20 ; value[$1.to_i] ||= 1 ; value[$1.to_i] *= (1 + ($2.to_f / 100)) #配列を出力(項目数2) when 21 ; value.push([$1.to_i, $2.to_i]) #IDへ加算処理(百分率処理)(項目数2) when 22 ; value[$1.to_i] ||= 0 ; value[$1.to_i] += ($2.to_f / 100) #IDへ加算処理(項目数2) when 23 ; value[$1.to_i] ||= 0 ; value[$1.to_i] += $2.to_i #IDへ配列を値を配列出力(項目数2) when 24 ; value[$1.to_i] ||= [] ; value[$1.to_i].push($2.to_i) #項目へ加算処理(百分率処理)(項目数2) when 25 ; value[0] += $1.to_i ; value[1] += ($2.to_f / 100) #単純加算処理 when 26 ; value[0] += $1.to_i ; value[1] += $2.to_i #多項目最大値適用 when 27 ; value[$1.to_i] = [value[$1.to_i], $2.to_i].max #単純代入 when 28 ; value = [$1.to_i, $2.to_i] end end when 30..39 if $1 && $2 && $3 case task_id #2重ID項目を加算処理(百分率処理)(項目数3) when 30 value[$1.to_i] ||= [] value[$1.to_i][$2.to_i] ||= 0 value[$1.to_i][$2.to_i] += ($3.to_f / 100) #配列を出力(項目数3) when 31 ; value.push([$1.to_i, $2.to_i, $3.to_i]) #IDへ配列を出力(項目数3) when 32 ; value[$1.to_i] ||= [] ; value[$1.to_i].push([$2.to_i,$3.to_i]) #2重ID項目を加算処理(項目数3) when 33 value[$1.to_i] ||= [] value[$1.to_i][$2.to_i] ||= 0 value[$1.to_i][$2.to_i] += $3.to_i #各項目の加算処理(項目数3) when 34 ; value[0] += ($1.to_f / 100) ; value[1] += ($2.to_f / 100) ; value[2] += ($3.to_f / 100) #IDへ項目を加算処理(項目数3) when 35 case $1.to_i when 0 ; value[$1.to_i][0] += $2.to_i ; value[$1.to_i][1] += $3.to_i when 1 ; value[$1.to_i][0] += $2.to_i ; value[$1.to_i][1] += $3.to_i end #2重ID項目を乗算処理(項目数3) when 36 value[$1.to_i] ||= [] value[$1.to_i][$2.to_i] ||= 1 value[$1.to_i][$2.to_i] *= ($3.to_f / 100) #各項目の単純加算処理(項目数3) when 37 ; value[0] += $1.to_i ; value[1] += $2.to_i ; value[2] += $3.to_i #2重ID項目配列出力処理(項目数3) when 38 value[$1.to_i] ||= [] ; value[$1.to_i][$2.to_i] ||= [] value[$1.to_i][$2.to_i].push($3.to_f / 100) #IDに配列を代入 when 39 ; value[$1.to_i] = [$2.to_i,$3.to_i] end end when 40..49 if $1 && $2 && $3 && $4 case task_id #配列を出力(項目数4) when 41 ; value.push([$1.to_i, $2.to_i, $3.to_i, $4.to_i]) #IDへ配列を出力(項目数4) when 42 ; value[$1.to_i] ||= [] ; value[$1.to_i].push([$2.to_i, $3.to_i, $4.to_i]) end end when 51..59 if $1 && $2 && $3 && $4 && $5 case task_id #配列出力 when 51 ; value.push([$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i]) #自動復活用特殊出力 when 52 ; value.push([$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $1.to_i]) end end when 61 if $1 && $2 && $3 && $4 && $5 && $6 value.push([$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i]) if $1 && $2 && $3 && $4 && $5 && $6 end #命中タイプ指定用配列出力 when 130 if $1 && $2 && $3 value[$1.to_i][$3.to_i] ||= [] value[$1.to_i][$3.to_i].push($2.to_i) end end note_data = $' end return value end #-------------------------------------------------------------------------- # ☆ パッシブスキルIDを取得(追加定義) #-------------------------------------------------------------------------- def self.passive_skill_id(cheak_note) result = [] result[0]= arr_num_slice(cheak_note.scan(/<パッシブ能力武器\s?(\d+(?:\s?*,\s?*\d+)*)>/)) result[1]= arr_num_slice(cheak_note.scan(/<パッシブ能力防具\s?(\d+(?:\s?*,\s?*\d+)*)>/)) result[2]= arr_num_slice(cheak_note.scan(/<パッシブ能力職業\s?(\d+(?:\s?*,\s?*\d+)*)>/)) result[3]= arr_num_slice(cheak_note.scan(/<パッシブ能力ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) return result end #-------------------------------------------------------------------------- # ☆ 数値配列に畳む(追加定義) #-------------------------------------------------------------------------- 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 #-------------------------------------------------------------------------- # ☆ アイテムオブジェクトの取得(追加定義) #-------------------------------------------------------------------------- def self.item_obj(kind, data_id) return $data_items [data_id] if kind == 0 return $data_weapons[data_id] if kind == 1 return $data_armors [data_id] if kind == 2 return nil end #-------------------------------------------------------------------------- # ☆ 特徴の文字配列の呼び出し(追加定義) #-------------------------------------------------------------------------- def self.call_effect_txt(item) draw_txt = Array.new #書きだし item.effects.each{|effect| case effect.code #HP回復,MP回復,TP回復 when 11,12,13 case effect.code when 11 ; txt = "HP " when 12 ; txt = "MP " when 13 ; txt = "TP " end if effect.value1 != 0 txt2 = "% 回復" if effect.value1 > 0 txt2 = "% 減少" if effect.value1 < 0 draw_txt.push(txt + (((effect.value1*100).abs).to_i).to_s + txt2) end if effect.value2 != 0 txt2 = " 回復" if effect.value2 > 0 txt2 = " 減少" if effect.value2 < 0 draw_txt.push(txt + ((effect.value2.abs).to_i).to_s + txt2) end when 21,22 case effect.code when 21 ; txt = " 付与 " when 22 ; txt = " 解除 " end name = effect.data_id == 0 ? "通常攻撃" : $data_states[effect.data_id].name draw_txt.push(name + txt + ((effect.value1*100).to_i).to_s + "%") when 31,32,33,34 case effect.code when 31 txt = " 強化付与 " txt2 = (effect.value1.to_i).to_s + "ターン" when 32 txt = " 弱体付与 " txt2 = (effect.value1.to_i).to_s + "ターン" when 33 txt = " 強化解除" txt2 = "" when 34 txt = " 弱体解除" txt2 = "" end draw_txt.push(Vocab::param(effect.data_id) + txt + txt2) when 41 draw_txt.push("逃走効果") when 42 draw_txt.push(Vocab::param(effect.data_id) + " 成長(" + (effect.value1.to_i).to_s + ")" ) when 43 draw_txt.push($data_skills[effect.data_id].name + " 習得") when 44 draw_txt.push("特殊効果") end } return draw_txt end #-------------------------------------------------------------------------- # ☆ 特徴の文字配列の呼び出し(追加定義) #-------------------------------------------------------------------------- def self.call_add_feature_txt(item) return [] unless item draw_txt = Array.new #コードのID配列を取得 object = item.is_a?(Game_Actor) ? item.all_features : item.features code_list = object.collect{|ft| case ft.code when 11,12,13,21,23,22,32,62,64 [ft.code, ft.data_id] when 14,31,41,42,43,44,51,52,53,54,55,33,34,61 [ft.code, 0] end } code_list.compact! code_list.uniq! #書きだし code_list.each{|block| case block[0] when 14,31,41,42,43,44,51,52,53,54,55,62,64 data = features_set_data(item, block[0]) case block[0] when 31 ; data.each{|id| draw_txt.push($data_system.elements[id] + "属性 ")} when 14 ; data.each{|id| draw_txt.push($data_states[id].name + "無効 ")} when 41 ; data.each{|id| draw_txt.push($data_system.skill_types[id] + "使用可 ")} when 42 ; data.each{|id| draw_txt.push($data_system.skill_types[id] + "使用不可 ")} when 43 ; data.each{|id| draw_txt.push($data_skills[id].name + "使用可 ")} when 44 ; data.each{|id| draw_txt.push($data_skills[id].name + "使用不可 ")} when 51 ; data.each{|id| draw_txt.push($data_system.weapon_types[id] + "装備可 ")} when 52 ; data.each{|id| draw_txt.push($data_system.armor_types[id] + "装備可 ")} when 53 ; data.each{|id| draw_txt.push($data_system.terms.etypes[id] + "固定 ")} when 54 ; data.each{|id| draw_txt.push($data_system.terms.etypes[id] + "封印 ")} when 55 ; draw_txt.push("二刀流 ") if data.max == 1 when 62 case block[1] when 0 ; draw_txt.push("自動戦闘 ") when 1 ; draw_txt.push("自動防御 ") when 2 ; draw_txt.push("自動献身 ") when 3 ; draw_txt.push("TP持越 ") end when 64 case block[1] when 0 ; draw_txt.push("敵出現率↓ ") when 1 ; draw_txt.push("敵出現率0 ") when 2 ; draw_txt.push("被先制無効 ") when 3 ; draw_txt.push("先制率上昇 ") when 4 ; draw_txt.push("獲得金額2倍 ") when 5 ; draw_txt.push("Drop率2倍 ") end end when 11,12,13,21,23 data = (features_pi_data(item, block[0], block[1]) * 100).to_i case block[0] when 11 ; draw_txt.push($data_system.elements[block[1]] + "有効度" + data.to_s + "% ") when 12 ; draw_txt.push(Vocab::param(block[1]) + "弱体有効度" + data.to_s + "% ") when 13 ; draw_txt.push($data_states[block[1]].name + "有効度" + data.to_s + "% ") when 21 data2 = data > 100 ? "+" + (data - 100).to_s : (data - 100).to_s draw_txt.push(Vocab::param(block[1]) + data2 + "% ") when 23 next if data == 100 case block[1] when 0 ; draw_str = "狙われ率" when 1 ; draw_str = "防御効果" when 2 ; draw_str = "回復効果" when 3 ; draw_str = "薬知識" when 4 ; draw_str = "MP消費率" when 5 ; draw_str = "TP上昇率" when 6 ; draw_str = "被物理Dmg" when 7 ; draw_str = "被魔法Dmg" when 8 ; draw_str = "床Dmg" when 9 ; draw_str = "経験値" end data2 = data > 100 ? "+" + (data - 100).to_s : (data - 100).to_s draw_txt.push(draw_str + data2 + "% ") end when 22,32 data = (features_sum_data(item, block[0], block[1]) * 100).to_i case block[0] when 22 case block[1] when 0 ; draw_str = "命中率" when 1 ; draw_str = "回避率" when 2 ; draw_str = "会心率" when 3 ; draw_str = "会心回避" when 4 ; draw_str = "魔法回避" when 5 ; draw_str = "魔法反射" when 6 ; draw_str = "反撃率" when 7 ; draw_str = "毎ﾀｰﾝHP回復" when 8 ; draw_str = "毎ﾀｰﾝMP回復" when 9 ; draw_str = "毎ﾀｰﾝTP回復" end data2 = data > 0 ? "+" + data.to_s : data.to_s draw_txt.push(draw_str + data2 + "% ") when 32 draw_txt.push($data_states[block[1]].name + "付与" + data.to_s + "% ") end when 33,34 data = features_sum_all_data(item, block[0]) case block[0] when 33 next if data == 0 draw_txt.push("攻撃速度増加") if data > 0 draw_txt.push("攻撃速度減少") if data < 0 when 34 next if data == 0 draw_txt.push("攻撃追加" + data.to_s + "回 ") if data > 0 draw_txt.push("攻撃減少" + data.to_s + "回 ") if data < 0 end when 61 data = features_data(item, 61).collect{|ft| (ft.value * 100).to_i} data.each{|id| draw_txt.push("追加行動" + id.to_s + "% ")} end } 130.times{|index| data = item.is_a?(Game_Actor) ? item.add_features_object(index) : item.adv_item_feature(index) str1 ="" ; str2= "" ; str3 ="" case index when 0..6,9..17,24..29,31,32,33,35,40,43,44,49..53,55,60,62..68,72,76..79,82,86..89,94,96,97,107 next if data == [] when 7,18,19,36,47,57,58,61,69..71,73,74,85,100,101 next if data == 1 when 8,20,21,23,37,45,46,48,81,102..106 next if data == 0 when 22,90 ; next if data == [0,0,0] when 30,34,41,38,39,42,98,99 ; next if data == [[],[],[],[]] #when ; next if data == [0,0,0,0] when 54 ; next if data == [[0,0],[0,0]] when 56 ; next if data == [0,1] when 59,91,92,93 ; next if data == [[],[],[]] when 75 ; next if data == [-1,-1] end case index when 0 data.each_with_index{|block, id| next unless block draw_txt.push(Vocab.param(id) + " " + sprintf("%+d", block))} when 1..6,9..17,25,51,75,77..79,82 data.each_with_index{|block, id| next unless block next if block == -1 && index == 75 case index when 1..3 ; str1 = $data_system.elements[id] when 4..6,25 ; str1 = Vocab.hit_type(id) when 9,10,51 ; str1 = $data_system.skill_types[id] when 11..13 ; str1 = $data_states[id].name when 14 ; str1 = $data_system.weapon_types[id] when 15..17 ; str1 = Vocab.basic(3 + id * 2) + "回復" when 75 ; str1 = "身代発動" when 77..79 ; str1 = Vocab.scope_type(id) when 82 ; str1 = Vocab.param(id) end case index when 1,4,9,11,14,15,77 ; str2 = "強化" when 2,5,12,16,78 ; str2 = "追加" when 3,6,10,13,79 ; str2 = "耐性" when 17 ; str2 = "弱化" when 25 ; str2 = "無効化" when 51 ; str2 = "連続発動" when 75 ; str2 = "(全)" if id == 1 when 82 ; str2 = "能力値" end case index when 1,4,9,11,14,15,77 ; str3 = sprintf("%+d%", (block * 100) - 100) when 2,3,5,6,10,12,13,16,17,25,78,79 ; str3 = sprintf("%+d%", block * 100) when 51 ; str3 = block.to_s + "回" when 75 ; str3 = block.to_s + "%" when 82 ; str3 = "変動" end draw_txt.push(str1 + str2 + str3)} when 7,8,18..23,36,37,45..48,56..58,61,69..71,73,81,85,90,100..106 case index when 7,8 ; str1 = "通常攻撃" when 18..21 ; str1 = "会心" when 23 ; str1 = "ダメージ上限" when 22 ; str1 = "逆境補正" when 45 ; str1 = "必中" when 46 ; str1 = "物理" when 36,37 ; str1 = "反撃" when 47,48 ; str1 = "反射" when 56 ; str1 = "最大TP変化" when 57 ; str1 = "TP" when 58 ; str1 = "HP" when 61 ; str1 = "スティール率" when 69 ; str1 = "全体遭遇率" when 70 ; str1 = "全体Drop率" when 71 ; str1 = "全体獲得金額率" when 73 ; str1 = "耐久値減少率" when 81 ; str1 = "Delay" when 85 ; str1 = "魔法命中" when 90 ; str1 = "反動変化" when 100..103 ; str1 = "ダメージ反射" when 104; str1 = "回復効果率無視" when 105; str1 = "分散度" when 104; str1 = "ステート有効度無視" end case index when 7,18,36,37,47,101 ; str2 = "強化" when 8,21,48,103 ; str2 = "耐性" when 19,100 ; str2 = "有効度" when 20,102 ; str2 = "追加" when 22 ; str2 = "(" + (data[0] * 100).to_i.to_s + "% " + (data[1] * 100).to_i.to_s + "% "+ (data[2] * 100).to_i.to_s + "%)" when 45,46 ; str2 = "反射" when 56 ; str2 = "(" + sprintf("%+d%", (data[1] * 100) - 100) + sprintf("%+d", data[0]) + ")" when 57,58 ; str2 = "消費率" when 81,105 ; str2 = data > 0 ? "増加" : "減少" when 90 ; str2 = "(" + data[0].to_s + " " + data[1].to_s + "% " end case index when 7,18,36,47,85,101 ; str3 = sprintf("%+d%", (data * 100) - 100) when 8,20,21,37,48,102,103 ; str3 = sprintf("%+d%", data * 100) when 23 ; str3 = "(" + data.to_s + ")" when 19,45,46,57,58,61,69..71,73,100 ; str3 = sprintf("%d%", data * 100) when 81,105 ; str3 = "(" + data.abs.to_s + ")" when 90 ; str3 = ")" end draw_txt.push(str1 + str2 + str3) when 24,26..29,32,33,35,40,43,44,49,50,52,55,60,62..68,72,76,87..89,94,96,97,98 data.each{|block| next unless block case index when 24 ; str1 = block[0].to_s when 26 ; str1 = "Dmg減少" when 27 ; str1 = "踏み止まり" when 28,29 ; str1 = $data_states[block].name when 32 ; str1 = "Dmg変換" when 33 ; str1 = "Dmg回収" when 35,40,49,62,63 ; str1 = Vocab.hit_type(block[0]) when 43 ; str1 = "スキル変化" when 44 ; str1 = "行動変化" when 50 ; str1 = "転換" when 52 ; str1 = "ステート" when 55 ; str1 = "特殊発動" when 60 ; str1 = "即死反転" when 64 ; str1 = "自動復活" when 65 ; str1 = "条件付与" when 66 ; str1 = "遅延付与" when 67 ; str1 = "特殊追撃" when 68 ; str1 = "自爆耐性" when 72 ; str1 = $data_system.skill_types[block[0]] when 76 ; str1 = "属性場展開" when 87 ; str1 = block when 88,89 ; str1 = $data_skills[block[0]].name when 94 ; str1 = "階級上昇補正 " when 96 ; str1 = "スキル変換能力" when 97 ; str1 = "アイテム変換能力" when 98 ; str1 = "命中変化能力" end case index when 24 ; str2 = "Dmg以下無効" when 26,32,33,43,50,55,64,67 ; str2 = block[2].to_s + "%" when 27,44,60 ; str2 = block[1].to_s + "%" when 29 ; str2 = "常時" when 35,52 ; str2 = "反撃無効化" when 40 ; str2 = "反撃" when 49 ; str2 = "反射無効化" when 62 ; str2 = "防御壁" when 63 ; str2 = "追撃無効化" when 65 ; str2 = "(" + $data_states[block[4]].name + " " when 66 ; str2 = "(" + $data_states[block[0]].name + " " when 72 ; str2 = "属性追加" when 88 ; str2 = "強化" when 89 ; str2 = "耐性" when 94 ; str2 = Vocab.param(block[0]) end case index when 26 ; str3 = "(" + block[1].to_s + "%+"+ block[0].to_s + ")" when 27,60,68 ; str3 = "(" + block[0].to_s + "%)" when 28,29 ; str3 = "付与" when 32,33 ; str3 = "(" + Vocab.drain_type(block[0]) + " " + block[1].to_s + "%)" when 35,49,52,63 ; str3 = block[1].to_s + "%" when 40 ; str3 = "(" + (block[1] != 0 ? $data_states[block[1]].name : "全属性") + " " + block[2].to_s + "%)" when 50 ; str3 = "(" + $data_states[block[0]].name + "→" + $data_states[block[1]].name + ")" when 55 ; str3 = "(" + (block[0] == 0 ? "開始時" : (block[0] == 1 ? "ターン前" : "ターン後")) + ")" when 62 ; str3 = "(" + block[2].to_s + "% "+ block[1].to_s + "回)" when 64 ; str3 = "(" + block[0].to_s + "T "+ block[1].to_s + "回)" when 65 ; str3 = Vocab.basic(3 + block[0] * 2) + ")" when 66 ; str3 = block[1].to_s + "T後)" when 67 ; str3 = "(" + $data_states[block[0]].name + ")" when 72 ; str3 = "("+ $data_system.elements[block[1]] +")" when 76 ; str3 = "("+ $data_system.elements[block[0]] + " " + block[1].to_s + ")" when 88,89 ; str3 = "(" + block[1].to_s + "%)" when 94 ; str3 = "(" + block[1].to_s + ")" end draw_txt.push(str1 + str2 + str3)} when 34,41 data.each_with_index{|block, id| next if block == [] str1 = Vocab.hit_type(id) case index when 34 ; str2 = "反撃変化" when 41 ; str2 = "最終反撃" end draw_txt.push(str1 + str2 + str3)} when 30,38,39,42,99 data.each_with_index{|block, id| next if block == [] block.each_with_index{|data ,e_id| next unless data next if data == 0 case index when 30 ; str1 = "反撃" when 38 ; str1 = "拡張反撃" when 39 ; str1 = "回避反撃" when 42 ; str1 = "身代反撃" when 99 ; str1 = "拡張反射" end str2 = "(" if id != 3 && e_id != 0 str2 += Vocab.hit_type(id) if id != 3 str2 += "," if id != 3 && e_id != 0 str2 += $data_system.elements[e_id] if e_id != 0 str2 += ")" if id != 3 && e_id != 0 str3 = sprintf("%d%", data * 100) draw_txt.push(str1 + str2 + str3)} } when 31,53,107 data.each{|block| next unless block case index when 31 ; str1 = "優先対象" when 53 ; str1 = "行動反応追撃" when 107 ; str1 = "貫通技能" end case index when 31 str2 = "(" + $data_system.elements[block] + ")" when 53 case block[0] when 0 ; str2 = "(" + $data_system.elements[block[1]] + ")" when 1 ; str2 = "(" + Vocab.hit_type(block[1]) + ")" if block[1] != 3 when 2 ; str2 = "(" + "回復" + ")" end str3 = block[3].to_s + "%" end draw_txt.push(str1 + str2 + str3)} when 54 data.each_with_index{|block, id| next if block == [0,0] case id when 0 ; str1 = "戦後回復(自) " when 1 ; str1 = "戦後回復(全) " end str2 = "HP" + block[0].to_s + "% " str3 = "MP" + block[1].to_s + "%" draw_txt.push(str1 + str2 + str3)} when 59,91,92,93 data.each_with_index{|block, id| next unless block block.each_with_index{|rate, type| next unless rate case id when 0 ; str1 = "MP消費(" when 1 ; str1 = "TP消費(" when 2 ; str1 = "HP消費(" end case index when 59,91 str2 = $data_system.skill_types[type] when 92,93 str2 = $data_system.elements[type] end case index when 59,92 str3 = "," + sprintf("%d%", rate * 100) + ")" when 91,93 rate2 = rate > 0 ? "+" + rate.to_s : rate.to_s str3 = "," + rate2 + ")" end draw_txt.push(str1 + str2 + str3)} } when 86 data.each_with_index{|block, id| next unless block next if block == [] block.each{|block2| next unless block2 next if block2 == [] str1 = $data_system.elements[id] str2 = "有効度" str3 = sprintf("%d%", (block2.inject(0.0){|r,i| r+=i } / block2.size)*100) draw_txt.push(str1 + str2 + str3) break } } end } return draw_txt end #-------------------------------------------------------------------------- # ★ 特徴オブジェクトの配列取得（特徴コードを限定）(追加定義) #-------------------------------------------------------------------------- def self.features_data(item, code) object = item.is_a?(Game_Actor) ? item.all_features : item.features object.select {|ft| ft.code == code } end #-------------------------------------------------------------------------- # ★ 特徴オブジェクトの配列取得（特徴コードとデータ ID を限定）(追加定義) #-------------------------------------------------------------------------- def self.features_with_id_data(item, code, id) object = item.is_a?(Game_Actor) ? item.all_features : item.features object.select {|ft| ft.code == code && ft.data_id == id } end #-------------------------------------------------------------------------- # ★ 特徴値の総乗計算(追加定義) #-------------------------------------------------------------------------- def self.features_pi_data(item, code, id) features_with_id_data(item, code, id).inject(1.0) {|r, ft| r *= ft.value } end #-------------------------------------------------------------------------- # ★ 特徴値の総和計算（データ ID を指定）(追加定義) #-------------------------------------------------------------------------- def self.features_sum_data(item, code, id) features_with_id_data(item, code, id).inject(0.0) {|r, ft| r += ft.value } end #-------------------------------------------------------------------------- # ★ 特徴値の総和計算（データ ID は非指定）(追加定義) #-------------------------------------------------------------------------- def self.features_sum_all_data(item, code) features_data(item, code).inject(0.0) {|r, ft| r += ft.value } end #-------------------------------------------------------------------------- # ★ 特徴の集合和計算(追加定義) #-------------------------------------------------------------------------- def self.features_set_data(item, code) features_data(item, code).inject([]) {|r, ft| r |= [ft.data_id] } end end #============================================================================== # ★ Vocab(追加定義) #============================================================================== module Vocab #-------------------------------------------------------------------------- # ★ 命中タイプ名を返す(追加定義) #-------------------------------------------------------------------------- def self.hit_type(id) case id ; when 0 ; "必中" ; when 1 ; "物理" ; when 2 ; "魔法" ; when 3 ; "" ; end end #-------------------------------------------------------------------------- # ★ 変換対象の項目名を返す(追加定義) #-------------------------------------------------------------------------- def self.drain_type(id) case id ; when 0 ; "MP" ; when 1 ; "TP" ; when 2 ; "G" ; end end #-------------------------------------------------------------------------- # ★ 効果範囲名を返す(追加定義) #-------------------------------------------------------------------------- def self.scope_type(id) str = "" case id when 0 ; str = "範囲無" when 1,3,7,11 ; str = "単体" when 2,8 ; str = "全体" when 4,5,6 ; str = "ランダム" end return str end end #============================================================================== # ●■ RPG::UsableItem(追加定義集積) #============================================================================== class RPG::UsableItem < RPG::BaseItem #-------------------------------------------------------------------------- # ★ 拡張設定の呼び出し(追加定義) #-------------------------------------------------------------------------- def adv_item_effect(id) @adv_effect_data ||= [] ; @adv_effect_flag ||= [] return Marshal.load(Marshal.dump(@adv_effect_data[id])) if @adv_effect_flag[id] @adv_effect_data[id] = call_adv_item_effect(id) @adv_effect_flag[id] = true return Marshal.load(Marshal.dump(@adv_effect_data[id])) end #-------------------------------------------------------------------------- # ★ 拡張設定の呼び出し(追加定義) #-------------------------------------------------------------------------- def call_adv_item_effect(id) result = [] case id when 0 ; result = KURE.add_feature_basic([0,0,0], @note, "消費HP", 37, 122) when 1 ; result = @note.include?("<自爆スキル>") when 2 ; result = KURE.add_feature_basic(0, @note, "反撃不可", 16, 2) when 3 ; result = KURE.add_feature_basic(0, @note, "反射不可", 16, 2) when 4 ; result = KURE.add_feature_basic(@repeats, @note, "連続回数追加", 15, 1) when 5 ; result = KURE.add_feature_basic(nil, @note, "発動前コモン", 16, 1) when 6 ; result = KURE.arr_num_slice(@note.scan(/<反映属性\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 7 ; result = @note.include?("<通常攻撃判定>") when 8 ; result = [@animation_id] + KURE.arr_num_slice(@note.scan(/<連続アニメーション\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 9 ; result = KURE.arr_num_slice(@note.scan(/<発動後ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 10 ; result = [@id] + KURE.arr_num_slice(@note.scan(/<連続発動スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 11 ; result = KURE.add_feature_basic([0,0], @note, "拡張消費MP", 26, 22) when 12 ; result = KURE.add_feature_basic([0,0], @note, "拡張消費TP", 26, 22) when 13 ; result = KURE.add_feature_basic(0, @note, "ステート初期化", 15, 2) when 14 ; result = KURE.add_feature_basic(nil, @note, "スティール", 16, 1) when 15 ; result = KURE.add_feature_basic([], @note, "防御壁追加", 51, 11211) when 16 ; result = KURE.add_feature_basic([], @note, "自動復活追加", 52, 11221) when 17 ; result = KURE.add_feature_basic([], @note, "遅延ステート追加", 31, 111) when 18 ; result = KURE.add_feature_basic([], @note, "トラップ設置", 61, 121111) when 19 ; result = KURE.add_feature_basic(0, @note, "トラップ無効", 16, 2) when 20 ; result = KURE.add_feature_basic([], @note, "耐久値操作", 41, 1121) when 21 ; result = KURE.add_feature_basic([], @note, "耐久値消費", 41, 1121) when 22 ; result = KURE.add_feature_basic([], @note, "武器強化", 20, 12) when 23 ; result = KURE.add_feature_basic([], @note, "ステート特効", 20, 12) when 24 ; result = KURE.add_feature_basic([], @note, "アイテム獲得", 51, 11211) when 25 ; result = KURE.add_feature_basic([], @note, "必要アイテム", 31, 111) when 26 ; result = KURE.arr_num_slice(@note.scan(/<必要武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 27 ; result = KURE.arr_num_slice(@note.scan(/<必要装備タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 28 ; result = KURE.add_feature_basic(0, @note, "二刀流専用", 11, 1) when 29 ; result = KURE.arr_num_slice(@note.scan(/<習得不可\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 30 ; result = KURE.add_feature_basic([], @note, "連鎖発動", 21, 12) when 31 ; result = KURE.arr_num_slice(@note.scan(/<初期化対象外\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 32 ; result = KURE.add_feature_basic([], @note, "消費パラメータ", 21, 11) when 33 ; result = KURE.add_feature_basic([], @note, "成長", 21, 11) when 34 ; result = KURE.add_feature_basic([], @note, "身代わり対象", 41, 1211) when 35 ; result = KURE.add_feature_basic(0, @note, "身代わり対象外", 16, 2) when 36 ; result = KURE.add_feature_basic(0, @note, "消費金額", 11, 1) when 37 ; result = KURE.add_feature_basic(nil, @note, "ロストスキル", 28, 21) when 38 ; result = KURE.add_feature_basic([], @note, "二刀流消費増加", 21, 11) when 39 ; result = KURE.arr_num_slice(@note.scan(/<拡張スキルタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 40 ; result = skill_delay when 41 ; result = KURE.add_feature_basic([], @note, "連携発動", 41, 1211) when 42 ; result = KURE.arr_num_slice(@note.scan(/<必要防具タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 43 ; result = KURE.add_feature_basic(0, @note, "障壁破壊", 16, 1) when 44 ; result = KURE.arr_num_slice(@note.scan(/<貫通能力\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 45 ; result = skill_delay_infinity when 46 ; result = KURE.arr_num_slice(@note.scan(/<必要習得スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 47 ; result = KURE.add_feature_basic(0, @note, "ディレイ操作", 15, 1) when 48 ; result = KURE.add_feature_basic(0, @note, "表示形式", 16, 1) when 49 ; result = KURE.add_feature_basic(nil, @note, "使用者ID代入", 16, 1) when 50 ; result = @note.include?("<即時発動>") when 51 ; result = @note.include?("<ステート有効度無視>") when 52 ; result = KURE.arr_num_slice(@note.scan(/<対象ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 53 ; result = KURE.add_feature_basic([], @note, "ステート転写", 24, 11) when 54 ; result = KURE.add_feature_basic([], @note, "ステート対応変化", 31, 111) when 55 ; result = KURE.add_feature_basic(0, @note, "会心率変化", 12, 2) when 56 ; result = KURE.add_feature_basic([], @note, "ステート判定能力", 39, 111) when 57 ; result = KURE.add_feature_basic([0,0,0], @note, "反動", 37, 121) when 58 ; result = KURE.arr_num_slice(@note.scan(/<発動要求装備タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 59 ; result = KURE.arr_num_slice(@note.scan(/<発動要求武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 60 ; result = KURE.arr_num_slice(@note.scan(/<対象隊列\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 61 ; result = KURE.arr_num_slice(@note.scan(/<発動要求防具タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) when 62 ; result = @note.include?("<威力分散>") when 63 ; result = @note.include?("<対象可変>") when 64 ; result = KURE.add_feature_basic(nil, @note, "対象ID代入", 16, 1) end return result end #-------------------------------------------------------------------------- # ★ 拡張設定の定義(追加定義) #-------------------------------------------------------------------------- def hp_cost ; adv_item_effect(0) ; end #HPコスト def life_cost? ; adv_item_effect(1) ; end #自爆スキル def impossible_counter ; adv_item_effect(2) ; end #反撃不可 def impossible_refrect ; adv_item_effect(3) ; end #反射不可 def repeats ; adv_item_effect(4) ; end #連続回数(再定義) def pre_common ; adv_item_effect(5) ; end #発動前コモン def reflect_elements ; adv_item_effect(6) ; end #反映属性 def normal_attack? ; adv_item_effect(7) ; end #通常攻撃判定 def multi_anim_effect ; adv_item_effect(8) ; end #連続アニメーション def after_add_state ; adv_item_effect(9) ; end #発動後ステート def multi_skill_effect ; adv_item_effect(10) ; end #連続発動スキル def mp_cost_ex ; adv_item_effect(11) ; end #拡張消費MP def tp_cost_ex ; adv_item_effect(12) ; end #拡張消費TP def clear_state_rate ; adv_item_effect(13) ; end #ステート初期化 def steal_id ; adv_item_effect(14) ; end #スティールID def deffence_wall_add ; adv_item_effect(15) ; end #防御壁追加 def auto_revive_add ; adv_item_effect(16) ; end #自動復活追加 def delay_state_add ; adv_item_effect(17) ; end #遅延ステート追加 def trap_setting ; adv_item_effect(18) ; end #トラップ設置 def impossible_trap ; adv_item_effect(19) ; end #トラップ無効 def durable_damage ; adv_item_effect(20) ; end #耐久値操作 def durable_cost ; adv_item_effect(21) ; end #耐久値消費 def weapon_revise ; adv_item_effect(22) ; end #武器強化 def state_revise ; adv_item_effect(23) ; end #ステート特効 def gain_items ; adv_item_effect(24) ; end #アイテム獲得 def need_items ; adv_item_effect(25) ; end #必要アイテム def required_add_wtype ; adv_item_effect(26) ; end #必要武器タイプ def required_add_etype ; adv_item_effect(27) ; end #必要装備タイプ def need_dual ; adv_item_effect(28) ; end #二刀流専用 def unuseable_actor ; adv_item_effect(29) ; end #習得不可 def chain_action ; adv_item_effect(30) ; end #連鎖発動 def not_clear_type ; adv_item_effect(31) ; end #初期化対象外ステートタイプ def pram_cost ; adv_item_effect(32) ; end #パラメータコスト def grow_pram ; adv_item_effect(33) ; end #成長 def substitute_add ; adv_item_effect(34) ; end #身代わり対象 def ignore_substitute ; adv_item_effect(35) ; end #身代わり不可 def gold_cost ; adv_item_effect(36) ; end #ゴールドコスト def lost_skill? ; adv_item_effect(37) ; end #ロストスキル def dual_cost ; adv_item_effect(38) ; end #二刀流消費増加 def add_skill_type ; adv_item_effect(39) ; end #拡張スキルタイプ def delay ; adv_item_effect(40) ; end #スキルディレイ def team_action ; adv_item_effect(41) ; end #連携発動 def required_add_atype ; adv_item_effect(42) ; end #必要防具タイプ def break_wall ; adv_item_effect(43) ; end #障壁破壊 def pierce_ability ; adv_item_effect(44) ; end #貫通能力 def delay_infinity ; adv_item_effect(45) ; end #無限ディレイ def required_skill ; adv_item_effect(46) ; end #必要スキル def delay_change ; adv_item_effect(47) ; end #ディレイ操作 def view_mode ; adv_item_effect(48) ; end #表示形式 def user_id_value ; adv_item_effect(49) ; end #使用者ID代入 def no_time_effect ; adv_item_effect(50) ; end #即時発動 def ignore_state_rate ; adv_item_effect(51) ; end #ステート有効度無視 def target_state ; adv_item_effect(52) ; end #対象ステート def copy_state ; adv_item_effect(53) ; end #ステート転写 def state_change_skill ; adv_item_effect(54) ; end #ステート対応変化 def cri_gain_rate ; adv_item_effect(55) ; end #会心発生増加 def state_param ; adv_item_effect(56) ; end #ステート判定能力 def self_react ; adv_item_effect(57) ; end #反動 def need_equip_passive ; adv_item_effect(58) ; end #発動要求装備タイプ def need_weapon_passive ; adv_item_effect(59) ; end #発動要求武器タイプ def target_file ; adv_item_effect(60) ; end #対象隊列 def need_armor_passive ; adv_item_effect(61) ; end #発動要求防具タイプ def dispersion ; adv_item_effect(62) ; end #威力分散 def target_change_skill ; adv_item_effect(63) ; end #対象可変 def target_id_value ; adv_item_effect(64) ; end #対象ID代入 #-------------------------------------------------------------------------- # ★ 武器強化の補正値を取得(追加定義) #-------------------------------------------------------------------------- def get_weapon_revise(id) weapon_revise[id] ? weapon_revise[id] : 1.0 end #-------------------------------------------------------------------------- # ★ ステート特効の補正値を取得(追加定義) #-------------------------------------------------------------------------- def get_state_revise(id) state_revise[id] ? state_revise[id] : 1.0 end #-------------------------------------------------------------------------- # ★ ステート判定能力の補正値を取得(追加定義) #-------------------------------------------------------------------------- def get_state_param(id) state_param[id] ? state_param[id] : [7, 7] end #-------------------------------------------------------------------------- # ☆ スキルディレイの定義(追加定義) #-------------------------------------------------------------------------- def skill_delay @note.match(/<スキルディレイ\s?(\d+)\s?>/) return $1 ? [1 + $1.to_i, @id] : nil end #-------------------------------------------------------------------------- # ☆ スキルディレイの定義(追加定義) #-------------------------------------------------------------------------- def skill_delay_infinity @note.include?("<無限ディレイ>") ? [-100, @id] : nil end end #============================================================================== # ■ RPG::EquipItem(再定義) #============================================================================== class RPG::EquipItem < RPG::BaseItem #-------------------------------------------------------------------------- # □ 装備タイプの定義(再定義) #-------------------------------------------------------------------------- def etype_id @note.match(/<装備タイプ\s?(\d+)\s?>/) return $1 ? $1.to_i : @etype_id end #-------------------------------------------------------------------------- # □ 発動スキルの定義(再定義) #-------------------------------------------------------------------------- def skill_effect_id @note.match(/<発動スキル\s?(\d+)\s?>/) return $1 ? $1.to_i : 1 end end #============================================================================== # ●■ RPG::BaseItem(追加定義集積) #============================================================================== class RPG::BaseItem #-------------------------------------------------------------------------- # ★ 拡張特徴の呼び出し(追加定義) #-------------------------------------------------------------------------- def adv_item_feature(id) @adv_feature_data ||= [] unless @adv_feature_flag 130.times{|index| @adv_feature_data[index] = KURE.call_add_feature(index, @note)} @adv_feature_flag = true end return Marshal.load(Marshal.dump(@adv_feature_data[id])) end #-------------------------------------------------------------------------- # ★ 破損状態の取得(追加定義) #-------------------------------------------------------------------------- def broken? ; false ; end #-------------------------------------------------------------------------- # ★ 使用可能時の取得(追加定義) #-------------------------------------------------------------------------- def occasion @note.match(/<発動スキル\s?(\d+)\s?>/) return $1 ? 1 : 3 end #-------------------------------------------------------------------------- # ★ 消耗の定義(追加定義) #-------------------------------------------------------------------------- def consumable ; false ; end end #============================================================================== # ■ RPG::Enemy(追加定義) #============================================================================== class RPG::Enemy < RPG::BaseItem #-------------------------------------------------------------------------- # ☆ アビリティポイントの定義(追加定義) #-------------------------------------------------------------------------- def ability_exp @note.match(/<アビリティポイント\s?(\d+)\s?>/) return $1 ? $1.to_i : 0 end #-------------------------------------------------------------------------- # ☆ 盗めるアイテムの定義(追加定義) #-------------------------------------------------------------------------- def steal_list KURE.add_feature_basic([], @note, "スティールリスト", 41, 1111) end #-------------------------------------------------------------------------- # ☆ ドロップアイテムの定義(再定義) #-------------------------------------------------------------------------- def drop_items @drop_items + add_drop_items end #-------------------------------------------------------------------------- # ☆ 追加ドロップアイテムの定義(追加定義) #-------------------------------------------------------------------------- def add_drop_items add_drop_items = Array.new cheak_note = @note while cheak_note do cheak_note.match(/<追加ドロップ\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)>/) if $1 && $2 && $3 new_drop = RPG::Enemy::DropItem.new new_drop.kind = $1.to_i new_drop.data_id = $2.to_i new_drop.denominator = $3.to_f add_drop_items.push(new_drop) end cheak_note = $' end return add_drop_items end #-------------------------------------------------------------------------- # ☆ 条件ドロップアイテムの定義(追加定義) #-------------------------------------------------------------------------- def condition_drop_items KURE.add_feature_basic([], @note, "条件ドロップ", 51, 11111) end #-------------------------------------------------------------------------- # ◇ レベルの定義(追加定義) #-------------------------------------------------------------------------- def level @note.match(/<レベル\s?(\d+)\s?>/) return $1 ? $1.to_i : 1 end end #============================================================================== # ■ RPG::State(追加定義) #============================================================================== class RPG::State < RPG::BaseItem #-------------------------------------------------------------------------- # ★ ステートタイプの定義(追加定義) #-------------------------------------------------------------------------- def state_type @note.match(/<ステートタイプ\s?(\d+)\s?>/) return $1 ? $1.to_i : 0 end #-------------------------------------------------------------------------- # ★ 前提ステートの定義(追加定義) #-------------------------------------------------------------------------- def basic_state KURE.arr_num_slice(@note.scan(/<前提ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end #-------------------------------------------------------------------------- # ★ ステート解除時付与の定義(追加定義) #-------------------------------------------------------------------------- def next_state KURE.arr_num_slice(@note.scan(/<解除時ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end #-------------------------------------------------------------------------- # ★ 相殺ステートタイプの定義(追加定義) #-------------------------------------------------------------------------- def offset_state_type KURE.arr_num_slice(@note.scan(/<相殺ステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end #-------------------------------------------------------------------------- # ★ 上書きステートの定義(追加定義) #-------------------------------------------------------------------------- def overwrite_state_type KURE.arr_num_slice(@note.scan(/<上書きステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)) end #-------------------------------------------------------------------------- # ★ 残留ステートの定義(追加定義) #-------------------------------------------------------------------------- def not_delete_state return true if @note.include?("<残留ステート>") return true if KURE.add_feature_basic(1, @note, "ドロップ率増加", 10, 2) != 1 return true if KURE.add_feature_basic(1, @note, "獲得額増加率", 10, 2) != 1 return false end #-------------------------------------------------------------------------- # ★ 上書きの定義(追加定義)(追加定義) #-------------------------------------------------------------------------- def overwrite_mode return 1 if @note.include?("<効果延長>") return 2 if @note.include?("<効果上書き不可>") return 0 end #-------------------------------------------------------------------------- # ★ アイテム仕様不可ステートの定義(追加定義) #-------------------------------------------------------------------------- def can_not_use_item return @note.include?("<アイテム使用不可>") end #-------------------------------------------------------------------------- # ★ パッシブ再構築対象外の定義(追加定義) #-------------------------------------------------------------------------- def not_passive_refresh return @note.include?("<再構築対象外>") end #-------------------------------------------------------------------------- # ★重複許容の定義(追加定義) #-------------------------------------------------------------------------- def multi_addable @note.match(/<重複許容\s?(\d+)\s?,\s?(\d+)\s?>/) return ($1 && $2) ? [$1.to_i, $2.to_i] : nil end end #移行暫定措置 #============================================================================== # ■ Kernel(追加定義) #============================================================================== module Kernel #-------------------------------------------------------------------------- # ☆ 特徴の文字配列の呼び出し(追加定義) #-------------------------------------------------------------------------- def call_add_feature_txt(item) KURE.call_add_feature_txt(item) end end