2136 lines
No EOL
75 KiB
Ruby
2136 lines
No EOL
75 KiB
Ruby
#==============================================================================
|
|
# ■併用化ベーススクリプトＢ for RGSS3 Ver5.03-β5
|
|
# □作成者 kure
|
|
#==============================================================================
|
|
|
|
$kure_base_script = {} if $kure_base_script == nil
|
|
$kure_base_script[:base_B] = 503
|
|
p "併用化ベーススクリプトB"
|
|
|
|
#==============================================================================
|
|
# ■ Kernel(追加定義)
|
|
#==============================================================================
|
|
module Kernel
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 配列振り分け操作(指定IDに値を加算)(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def arr_id_value_flatten(arr)
|
|
result_arr = Array.new
|
|
for i in 0..arr.size - 1
|
|
if i % 2 == 0 && arr[i] && arr[i+1]
|
|
result_arr[arr[i]] ||= 0
|
|
result_arr[arr[i]] += arr[i+1]
|
|
end
|
|
end
|
|
return result_arr
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 配列振り分け操作(指定IDに値を出力)(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def arr_id_value_push(arr)
|
|
result_arr = Array.new
|
|
for i in 0..arr.size - 1
|
|
if i % 2 == 0 && arr[i] && arr[i+1]
|
|
result_arr[arr[i]] ||= []
|
|
result_arr[arr[i]].push(arr[i+1])
|
|
end
|
|
end
|
|
return result_arr
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 配列振り分け操作(指定個数毎にパッケージ)(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def arr_id_value_pack(arr, num)
|
|
result_arr = Array.new
|
|
first = 0
|
|
|
|
while first < arr.size - 1 do
|
|
last = first + num - 1
|
|
result_arr.push(arr[first..last])
|
|
first = last + 1
|
|
end
|
|
return result_arr
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 配列振り分け操作(数値にスライス)(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def arr_num_slice(arr)
|
|
result_arr = Array.new
|
|
unless arr == [] and arr.empty?
|
|
arr.flatten!
|
|
arr.each do |value|
|
|
value.scan(/\d+/).each { |num| result_arr.push(num.to_i)}
|
|
end
|
|
end
|
|
return result_arr
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アクター追加能力呼び出し(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def call_add_feature(id, note_data)
|
|
|
|
battler_add = Array.new
|
|
cheak_note = ""
|
|
cheak_note = note_data if note_data
|
|
|
|
case id
|
|
when 0
|
|
#スティール成功率(割合出力)
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<スティール成功率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 1
|
|
#オートリザレクション(配列最大値出力)
|
|
read_arr = [0,0,0,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<オートリザレクション\s?(\d+)%\s?,\s?(\d+)%\s?,\s?(\d+)\s?,\s?(\d+)>/)
|
|
if $1 && $2 && $3 && $4
|
|
value = [[read_arr[0],$1.to_i].max,[read_arr[1],$2.to_i].max,[read_arr[2],$3.to_i].max,[read_arr[3],$4.to_i].max]
|
|
read_arr = value
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 2
|
|
#踏みとどまり(最大効果出力)
|
|
read_arr = [150,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<踏みとどまり\s?(\d+)%\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr[0] = $1.to_i if $1.to_i < read_arr[0]
|
|
read_arr[1] = $2.to_i if $2.to_i > read_arr[1]
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 3
|
|
#回復反転(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<回復反転\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f / 100
|
|
|
|
when 4
|
|
#オートステート(配列出力)
|
|
list = cheak_note.scan(/<オートステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 5
|
|
#メタルボディ(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<メタルボディ\s?(\d+)\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 6
|
|
#連続使用(配列出力)
|
|
list = cheak_note.scan(/<連続発動\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
multi_use = arr_num_slice(list)
|
|
battler_add = arr_id_value_flatten(multi_use)
|
|
|
|
when 7
|
|
#即死反転(true,false出力)
|
|
battler_add = false
|
|
battler_add = true if cheak_note.include?("<即死反転>")
|
|
|
|
when 8
|
|
#仲間想い(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<仲間想い\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 9
|
|
#弱気(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<弱気\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 10
|
|
#防御壁(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<防御壁展開\s?(\d+)\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 11
|
|
#無効化障壁(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<無効化障壁\s?(\d+)\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 12
|
|
#TP消費率(割合出力)
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<TP消費率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 13
|
|
#スキル変化(配列出力)
|
|
list = cheak_note.scan(/<スキル変化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
change_skill = arr_num_slice(list)
|
|
battler_add = arr_id_value_push(change_skill)
|
|
|
|
when 14
|
|
#武器タイプスキル強化(配列出力)
|
|
list = cheak_note.scan(/<武器スキル倍率強化\s?(\d+-\d+-\d+(?:\s?*,\s?*\d+-\d+-\d+)*)>/)
|
|
gain_skill = arr_num_slice(list)
|
|
|
|
value = Array.new
|
|
for list in 0..gain_skill.size - 1
|
|
if list % 3 == 0
|
|
if gain_skill[list] && gain_skill[list + 1] && gain_skill[list + 2]
|
|
value[gain_skill[list]] = [] unless value[gain_skill[list]]
|
|
value[gain_skill[list]][gain_skill[list + 1]] = 0 unless value[gain_skill[list]][gain_skill[list + 1]]
|
|
value[gain_skill[list]][gain_skill[list + 1]] += gain_skill[list + 2]
|
|
end
|
|
end
|
|
end
|
|
battler_add = value
|
|
|
|
when 15
|
|
#行動変化(配列出力)
|
|
list = cheak_note.scan(/<行動変化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
change_skill = arr_num_slice(list)
|
|
battler_add = arr_id_value_pack(change_skill, 2)
|
|
|
|
when 16
|
|
#最終反撃(配列出力)
|
|
list = cheak_note.scan(/<最終反撃\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 17
|
|
#反撃スキル(配列出力)
|
|
list = cheak_note.scan(/<反撃スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 18
|
|
#戦闘終了後自動回復(配列最大値出力)
|
|
auto_heel = [0,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<戦闘後回復\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
auto_heel= [[auto_heel[0],$1.to_i].max,[auto_heel[1],$2.to_i].max]
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = auto_heel
|
|
|
|
when 19
|
|
#HPタイプ消費率(配列出力)
|
|
tp_cost = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<HPタイプ消費率\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
tp_cost[$1.to_i] = 1 unless tp_cost[$1.to_i]
|
|
tp_cost[$1.to_i] *= ($2.to_f / 100)
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = tp_cost
|
|
|
|
when 20
|
|
#MPタイプ消費率(配列出力)
|
|
tp_cost = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<MPタイプ消費率\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
tp_cost[$1.to_i] = 1 unless tp_cost[$1.to_i]
|
|
tp_cost[$1.to_i] *= ($2.to_f / 100)
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = tp_cost
|
|
|
|
when 21
|
|
#TPタイプ消費率(配列出力)
|
|
tp_cost = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<TPタイプ消費率\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
tp_cost[$1.to_i] = 1 unless tp_cost[$1.to_i]
|
|
tp_cost[$1.to_i] *= ($2.to_f / 100)
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = tp_cost
|
|
|
|
when 22
|
|
#HP消費率(割合出力)
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<HP消費率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 23
|
|
#オーバーソウル(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<オーバーソウル\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 24
|
|
#反撃強化(割合加算出力)
|
|
read_value = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<反撃強化\s?(\d+)%\s?>/)
|
|
read_value += ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_value
|
|
|
|
when 25
|
|
#HP減少時強化能力(最大値配列出力)
|
|
read_arr = [0,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<HP減少時強化\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr= [[read_arr[0],$1.to_i].max,[read_arr[1],$2.to_i].max]
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 26
|
|
#ダメージMP変換(最小値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<ダメージMP変換\s?(\d+)%\s?>/)
|
|
if $1
|
|
read_arr = $1.to_i if read_arr == 0
|
|
read_arr = [read_arr,$1.to_i].min if read_arr != 0
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
|
|
when 27
|
|
#ダメージG変換(最小値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<ダメージゴールド変換\s?(\d+)%\s?>/)
|
|
if $1
|
|
read_arr = $1.to_i if read_arr == 0
|
|
read_arr = [read_arr,$1.to_i].min if read_arr != 0
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f / 100
|
|
|
|
when 28
|
|
#必中反撃判定(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<必中反撃\s?(\d+)%\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 29
|
|
#魔法反撃判定(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<魔法反撃\s?(\d+)%\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 30
|
|
#追撃ステート(配列出力)
|
|
list = cheak_note.scan(/<追撃対象ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
read_arr = arr_num_slice(list)
|
|
|
|
when 31
|
|
#耐久値減少率(最小値出力)
|
|
read_arr = 100
|
|
while cheak_note do
|
|
cheak_note.match(/<耐久値減少率\s?(\d+)%\s?>/)
|
|
if $1
|
|
read_arr = [read_arr,$1.to_i].min
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 32
|
|
#ディレイステート(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<ディレイステート\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 33
|
|
#トリガー発動ステート(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<トリガーステート\s?([HMT])\s?,\s?(\d+)\s?,\s?(\d+)%\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2 && $3 && $4
|
|
case $1
|
|
when "H"
|
|
tri = 1
|
|
when "M"
|
|
tri = 2
|
|
when "T"
|
|
tri = 3
|
|
end
|
|
read_arr.push([tri, $2.to_i ,$3.to_i, $4.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 34
|
|
#自爆耐性(true,false出力)
|
|
battler_add = false
|
|
battler_add = true if cheak_note.include?("<自爆耐性>")
|
|
|
|
when 35
|
|
#ダメージMP吸収(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<ダメージMP吸収\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 36
|
|
#ダメージG吸収(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<ダメージゴールド回収\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 37
|
|
#戦闘開始時自動発動能力(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<戦闘開始時発動\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 38
|
|
#ターン開始時自動発動能力(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<ターン開始時発動\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 39
|
|
#ターン終了時自動発動能力(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<ターン終了時発動\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 40
|
|
#拡張反撃判定(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<拡張反撃\s?(\d+)%\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 41
|
|
#拡張魔法反撃判定(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<拡張魔法反撃\s?(\d+)%\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 42
|
|
#拡張必中反撃判定(加算出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<拡張必中反撃\s?(\d+)%\s?>/)
|
|
read_arr += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr.to_f/100
|
|
|
|
when 43
|
|
#常時オートステート(配列出力)
|
|
list = cheak_note.scan(/<常時オートステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 44
|
|
#最大TP増減(配列出力)
|
|
read_arr = [0,100]
|
|
gain_cheak_note = cheak_note.clone
|
|
decrease_cheak_note = cheak_note.clone
|
|
#最大TP増加
|
|
while gain_cheak_note do
|
|
gain_cheak_note.match(/<最大TP増加\s?(\d+)([%])?>/)
|
|
if $2 && $1
|
|
read_arr[1] += $1.to_i
|
|
elsif $1
|
|
read_arr[0] += $1.to_i
|
|
end
|
|
gain_cheak_note = $'
|
|
end
|
|
|
|
#最大TP減少
|
|
while decrease_cheak_note do
|
|
decrease_cheak_note.match(/<最大TP減少\s?(\d+)([%])?>/)
|
|
if $2 && $1
|
|
read_arr[1] -= $1.to_i
|
|
elsif $1
|
|
read_arr[0] -= $1.to_i
|
|
end
|
|
decrease_cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 45
|
|
#オートガード(最大値出力)
|
|
read_arr = [0,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<オートガード\s?(\d+)%\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr[0] = $1.to_i if $1.to_i > read_arr[0]
|
|
read_arr[1] = $2.to_i if $2.to_i > read_arr[1]
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 46
|
|
#必中無効化(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<必中無効化\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 47
|
|
#物理無効化(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<物理無効化\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 48
|
|
#魔法無効化(最大値出力)
|
|
read_arr = 0
|
|
while cheak_note do
|
|
cheak_note.match(/<魔法無効化\s?(\d+)%\s?>/)
|
|
read_arr = [read_arr,$1.to_i].max if $1
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 49
|
|
#戦闘終了後全体自動回復(加算出力)
|
|
auto_heel = [0,0]
|
|
while cheak_note do
|
|
cheak_note.match(/<戦闘後全体回復\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
auto_heel[0] += $1.to_i
|
|
auto_heel[1] += $2.to_i
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = auto_heel
|
|
|
|
when 50
|
|
#カウンターステート(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<カウンターステート\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
|
|
when 51
|
|
#反撃スキル(配列出力)
|
|
list = cheak_note.scan(/<物理反撃スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 52
|
|
#反撃スキル(配列出力)
|
|
list = cheak_note.scan(/<魔法反撃スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 53
|
|
#反撃スキル(配列出力)
|
|
list = cheak_note.scan(/<必中反撃スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
battler_add = arr_num_slice(list)
|
|
|
|
when 54
|
|
#属性場展開能力(配列出力)
|
|
read_arr = Array.new
|
|
while cheak_note do
|
|
cheak_note.match(/<属性場展開\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
read_arr.push([$1.to_i, $2.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
battler_add = read_arr
|
|
end
|
|
|
|
return battler_add
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ブースター能力呼び出し(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def call_multi_booster(id, note_data)
|
|
cheak_note = ""
|
|
cheak_note = note_data if note_data
|
|
|
|
case id
|
|
when 0
|
|
list = cheak_note.scan(/<属性強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 1
|
|
list = cheak_note.scan(/<属性吸収\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 2
|
|
list = cheak_note.scan(/<武器強化物理\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 3
|
|
list = cheak_note.scan(/<武器強化魔法\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 4
|
|
list = cheak_note.scan(/<武器強化必中\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 5
|
|
list = cheak_note.scan(/<通常攻撃強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 6
|
|
list = cheak_note.scan(/<ステート割合強化タイプ\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 7
|
|
list = cheak_note.scan(/<ステート固定強化タイプ\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 8
|
|
list = cheak_note.scan(/<ステート指定割合強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 9
|
|
list = cheak_note.scan(/<ステート指定固定強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
when 10
|
|
list = cheak_note.scan(/<スキルタイプ強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
end
|
|
return arr_num_slice(list)
|
|
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ パーティー能力呼び出し(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def call_party_add_feature(id, note_data)
|
|
party_add = Array.new
|
|
cheak_note = ""
|
|
cheak_note = note_data if note_data
|
|
|
|
case id
|
|
when 0
|
|
#獲得金額倍率設定(割合出力)
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<獲得金額倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
when 1
|
|
#アイテムドロップ率の設定
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<獲得アイテム倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
when 2
|
|
#エンカウント率の設定
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<エンカウント倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
when 3
|
|
#獲得経験値倍率の設定
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<獲得経験値倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
when 4
|
|
#獲得職業経験値倍率の設定
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<獲得職業経験値倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
when 5
|
|
#獲得職業経験値倍率の設定
|
|
read_arr = 1
|
|
while cheak_note do
|
|
cheak_note.match(/<獲得装備経験値倍率\s?(\d+)%\s?>/)
|
|
read_arr *= ($1.to_f / 100) if $1
|
|
cheak_note = $'
|
|
end
|
|
party_add = read_arr
|
|
|
|
end
|
|
return party_add
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 特徴の文字配列の呼び出し(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def call_add_feature_txt(item)
|
|
draw_txt = Array.new
|
|
|
|
#書きだし
|
|
#攻撃属性
|
|
draw_list = item.features_set_data(31)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_system.elements[id] + "属性 ")
|
|
end
|
|
|
|
roop = $data_system.elements.size - 1
|
|
#属性耐性
|
|
for id in 1..roop
|
|
draw_list = item.features_pi_data(11, id)
|
|
next if draw_list == 1
|
|
draw_s = 100 - (draw_list * 100).to_i
|
|
draw_txt.push($data_system.elements[id] + "耐性" + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#弱体化耐性
|
|
roop = 7
|
|
for id in 0..roop
|
|
draw_list = item.features_pi_data(12, id)
|
|
next if draw_list == 1
|
|
draw_s = 100 - (draw_list * 100).to_i
|
|
draw_txt.push("耐" + Vocab::param(id) + "減少" + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#ステート耐性
|
|
roop = $data_states.size - 1
|
|
for id in 0..roop
|
|
draw_list = item.features_pi_data(13, id)
|
|
next if draw_list == 1
|
|
draw_s = 100 - (draw_list * 100).to_i
|
|
draw_txt.push($data_states[id].name + "耐性" + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#ステート無効化
|
|
draw_list = item.features_set_data(14)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_states[id].name + "無効 ")
|
|
end
|
|
|
|
#通常能力
|
|
roop = 7
|
|
for id in 0..roop
|
|
draw_list = item.features_pi_data(21, id)
|
|
next if draw_list == 1
|
|
draw_s = (draw_list * 100).to_i - 100
|
|
draw_s = "+" + draw_s.to_s if draw_s > 0
|
|
draw_txt.push(Vocab::param(id) + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#特殊能力
|
|
for id in 0..9
|
|
case id
|
|
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
|
|
draw_list = item.features_sum_data(22, id)
|
|
next if draw_list == 0
|
|
draw_s = (draw_list * 100).to_i
|
|
draw_s = "+" + draw_s.to_s if draw_s > 0
|
|
draw_txt.push(draw_str + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#特殊能力値
|
|
for id in 0..9
|
|
case id
|
|
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
|
|
draw_list = item.features_pi_data(23, id)
|
|
next if draw_list == 1
|
|
draw_s = (draw_list * 100).to_i - 100
|
|
draw_s = "+" + draw_s.to_s if draw_s > 0
|
|
draw_txt.push(draw_str + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#攻撃時ステート判定
|
|
roop = $data_states.size - 1
|
|
for id in 0..roop
|
|
draw_list = item.features_sum_data(32, id)
|
|
next if draw_list == 0
|
|
draw_s = (draw_list * 100).to_i
|
|
draw_txt.push($data_states[id].name + "追加" + draw_s.to_s + "% ")
|
|
end
|
|
|
|
#攻撃速度
|
|
draw_list = item.features_sum_all_data(33)
|
|
unless draw_list == 0
|
|
draw_txt.push("攻撃速度増加") if draw_list > 0
|
|
draw_txt.push("攻撃速度減少") if draw_list < 0
|
|
end
|
|
|
|
#攻撃追加
|
|
draw_list = item.features_sum_all_data(34)
|
|
unless draw_list == 0
|
|
draw_txt.push("攻撃追加" + draw_list.to_s + "回" ) if draw_list > 0
|
|
draw_txt.push("攻撃減少" + draw_list.abs.to_s + "回" ) if draw_list < 0
|
|
end
|
|
|
|
#スキルタイプ追加
|
|
draw_list = item.features_set_data(41)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_system.skill_types[id] + "使用可 ")
|
|
end
|
|
|
|
#スキルタイプ削除
|
|
draw_list = item.features_set_data(42)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_system.skill_types[id] + "使用不可 ")
|
|
end
|
|
|
|
#スキル追加
|
|
draw_list = item.features_set_data(43)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_skills[id].name + "使用可 ")
|
|
end
|
|
|
|
#スキル削除
|
|
draw_list = item.features_set_data(44)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_skills[id].name + "使用不可 ")
|
|
end
|
|
|
|
#装備固定
|
|
draw_list = item.features_set_data(53)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_system.terms.etypes[id] + "固定 ")
|
|
end
|
|
|
|
#装備封印
|
|
draw_list = item.features_set_data(54)
|
|
draw_list.each do |id|
|
|
draw_txt.push($data_system.terms.etypes[id] + "封印 ")
|
|
end
|
|
|
|
#追加行動
|
|
draw_list = item.features_data(61).collect{|ft| ft.value * 100}
|
|
draw_list.each do |id|
|
|
draw_txt.push("追加行動" + id.to_s + "% ")
|
|
end
|
|
|
|
#特殊フラグ
|
|
for i in 0..3
|
|
case i
|
|
when 0
|
|
value = "自動戦闘"
|
|
when 1
|
|
value = "自動防御"
|
|
when 2
|
|
value = "自動献身"
|
|
when 3
|
|
value = "TP持越"
|
|
end
|
|
draw_txt.push(value) if item.features_data(62).any?{|ft| ft.data_id == i }
|
|
end
|
|
|
|
#パーティー能力
|
|
for i in 0..5
|
|
case i
|
|
when 0
|
|
value = "敵出現率↓"
|
|
when 1
|
|
value = "敵出現率0"
|
|
when 2
|
|
value = "被先制無効"
|
|
when 3
|
|
value = "先制率上昇"
|
|
when 4
|
|
value = "獲得金額2倍"
|
|
when 5
|
|
value = "Drop率2倍"
|
|
end
|
|
draw_txt.push(value) if item.features_data(64).any?{|ft| ft.data_id == i }
|
|
end
|
|
|
|
|
|
#追加特徴項目
|
|
for i in 0..54
|
|
data = item.battler_add_ability(i)
|
|
case i
|
|
when 0
|
|
draw_txt.push("スティール率" + data.to_s + "倍") if data != 1
|
|
when 1
|
|
draw_txt.push("自動復活(" + data[2].to_s + ")" + data[1].to_s + "%") if data[1] != 0
|
|
when 2
|
|
draw_txt.push("踏止(" + data[0].to_s + ")" + data[1].to_s + "%") if data != [150,0]
|
|
when 3
|
|
draw_txt.push("回復反転" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 4,43
|
|
data.each do |id|
|
|
draw_txt.push($data_states[id].name + "発動")
|
|
end
|
|
when 5
|
|
draw_txt.push("メタルボディ(" + data.to_s + ")") if data != 0
|
|
when 6
|
|
for type in 1..data.size - 1
|
|
next if data[type] == nil or data[type] == 0
|
|
draw_txt.push($data_system.skill_types[type] + data[type].to_s + "回発動")
|
|
end
|
|
when 7
|
|
draw_txt.push("即死反転") if data
|
|
when 8
|
|
draw_txt.push("仲間思い" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 9
|
|
draw_txt.push("弱気" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 10
|
|
draw_txt.push("防御壁展開(" + data.to_s + ")") if data != 0
|
|
when 11
|
|
draw_txt.push("無効化障壁(" + data.to_s + ")") if data != 0
|
|
when 12
|
|
draw_txt.push("TP消費率" + ((data*100).to_i).to_s + "%") if data != 1
|
|
when 13
|
|
draw_txt.push("スキル変化") if data != []
|
|
when 14
|
|
for wtype in 1..data.size - 1
|
|
next unless data[wtype]
|
|
for stype in 0..data[wtype].size - 1
|
|
next if data[wtype][stype] == nil or data[wtype][stype] == 0
|
|
draw_txt.push($data_system.skill_types[stype] + "強化(" + $data_system.weapon_types[wtype] +")"+ data[wtype][stype].to_s + "%")
|
|
end
|
|
end
|
|
when 15
|
|
draw_txt.push("行動変化") if data != []
|
|
when 16
|
|
draw_txt.push("最終反撃") if data != []
|
|
when 17
|
|
draw_txt.push("反撃変化") if data != []
|
|
when 18
|
|
draw_txt.push("戦後回復("+ data[0].to_s + "%," + data[1].to_s+ "%)" ) if data != [0,0]
|
|
when 19,20,21
|
|
value = "HP消費" if i == 19
|
|
value = "MP消費" if i == 20
|
|
value = "TP消費" if i == 21
|
|
for type in 1..data.size - 1
|
|
next if data[type] == nil or data[type] == 1
|
|
draw_txt.push(value + ((data[type]*100).to_i).to_s + "%(" + $data_system.skill_types[type] +")")
|
|
end
|
|
when 22
|
|
draw_txt.push("HP消費率" + ((data*100).to_i).to_s + "%") if data != 1
|
|
when 23
|
|
draw_txt.push("憑依強化" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 24
|
|
draw_txt.push("反撃強化" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 25
|
|
draw_txt.push( "逆境強化(" + data[0].to_s + ")" + data[1].to_s + "%" ) if data != [0,0]
|
|
when 26
|
|
draw_txt.push("衝撃MP変換" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 27
|
|
draw_txt.push("衝撃G変換" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 28
|
|
draw_txt.push("必中反撃" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 29
|
|
draw_txt.push("魔法反撃" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 30
|
|
data.each do |id|
|
|
draw_txt.push($data_states[id].name + "追撃")
|
|
end
|
|
when 31
|
|
draw_txt.push("耐久減少率" + ((data*100).to_i).to_s + "%") if data != 1
|
|
when 32
|
|
draw_txt.push("遅延ステート") if data != []
|
|
when 33
|
|
draw_txt.push("条件ステート") if data != []
|
|
when 34
|
|
draw_txt.push("自爆耐性") if data
|
|
when 35
|
|
draw_txt.push("衝撃MP吸収" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 36
|
|
draw_txt.push("衝撃G回収" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 37
|
|
draw_txt.push("開始時発動") if data != []
|
|
when 38
|
|
draw_txt.push("ターン開始時発動") if data != []
|
|
when 39
|
|
draw_txt.push("ターン終了時発動") if data != []
|
|
when 40
|
|
draw_txt.push("拡張反撃" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 41
|
|
draw_txt.push("拡張魔法反撃" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 42
|
|
draw_txt.push("拡張必中反撃" + ((data*100).to_i).to_s + "%") if data != 0
|
|
when 43
|
|
data.each do |id|
|
|
draw_txt.push($data_states[id].name + "発動")
|
|
end
|
|
when 44
|
|
next if data == [0,100]
|
|
if data[0] != 0
|
|
gain = ""
|
|
gain = "+" if data[0] > 0
|
|
draw_txt.push("最大TP" + gain + data[0].to_s)
|
|
end
|
|
if data[1] != 0
|
|
gain = ""
|
|
gain = "+" if data[1] > 0
|
|
draw_txt.push("最大TP" + gain + data[0].to_s + "%")
|
|
end
|
|
when 45
|
|
draw_txt.push("自動防御("+ data[1].to_s + "%," + data[0].to_s+ "%)" ) if data != [0,0]
|
|
when 46
|
|
draw_txt.push("必中無効" + data.to_s + "%") if data != 0
|
|
when 47
|
|
draw_txt.push("物理無効" + data.to_s + "%") if data != 0
|
|
when 48
|
|
draw_txt.push("魔法無効" + data.to_s + "%") if data != 0
|
|
when 49
|
|
draw_txt.push("戦後全体回復("+ data[0].to_s + "%," + data[1].to_s+ "%)" ) if data != [0,0]
|
|
when 50
|
|
next if data == []
|
|
data.each do |obj|
|
|
draw_txt.push("反撃付与(" + $data_states[obj[0]].name + obj[1].to_s + "%")
|
|
end
|
|
when 51
|
|
draw_txt.push("物理反撃変化") if data != []
|
|
when 52
|
|
draw_txt.push("魔法反撃変化") if data != []
|
|
when 53
|
|
draw_txt.push("必中反撃変化") if data != []
|
|
when 54
|
|
next if data == []
|
|
data.each do |obj|
|
|
draw_txt.push("属性場展開(" + $data_system.elements[obj[0]] + ")" )
|
|
end
|
|
end
|
|
end
|
|
|
|
#追加特徴項目
|
|
for i in 0..10
|
|
data = arr_id_value_flatten(item.multi_booster(i))
|
|
next if data == []
|
|
case i
|
|
when 0,1
|
|
value = "強化" if i == 0
|
|
value = "吸収" if i == 1
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push($data_system.elements[id] + value + data[id].to_s + "%")
|
|
end
|
|
when 2,3,4,5
|
|
value = "物理強化" if i == 2
|
|
value = "魔法強化" if i == 3
|
|
value = "必中強化" if i == 4
|
|
value = "通常強化" if i == 5
|
|
for id in 0..data.size - 1
|
|
next if data[id] == nil
|
|
next if id == 0 && i < 5
|
|
weapon = $data_system.weapon_types[id]
|
|
weapon = "素手" if id == 0 && i == 5
|
|
draw_txt.push(value + "(" + weapon + ")" + data[id].to_s + "%")
|
|
end
|
|
when 6
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push("付与率(" + $data_system.skill_types[id] + ")" + (data[id].to_f / 100).to_s + "倍")
|
|
end
|
|
when 7
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push("付与率(" + $data_system.skill_types[id] + ")+" + data[id].to_s + "%")
|
|
end
|
|
when 8
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push($data_states[id].name + "付与率" + (data[id].to_f / 100).to_s + "倍")
|
|
end
|
|
when 9
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push($data_states[id].name + "付与率+" + data[id].to_s + "%")
|
|
end
|
|
when 10
|
|
for id in 1..data.size - 1
|
|
next if data[id] == nil or data[id] == 0
|
|
draw_txt.push($data_system.skill_types[id] + "強化" + data[id].to_s + "%")
|
|
end
|
|
end
|
|
end
|
|
|
|
for i in 0..5
|
|
data = item.party_add_ability(i)
|
|
next if data == 1
|
|
case i
|
|
when 0
|
|
draw_txt.push("獲得金額" + data.to_s + "倍")
|
|
when 1
|
|
draw_txt.push("Drop率" + data.to_s + "倍")
|
|
when 2
|
|
draw_txt.push("遭遇率" + data.to_s + "倍")
|
|
when 3
|
|
draw_txt.push("獲得EXP" + data.to_s + "倍")
|
|
when 4
|
|
draw_txt.push("獲得JEXP" + data.to_s + "倍")
|
|
when 5
|
|
draw_txt.push("獲得装備EXP" + data.to_s + "倍")
|
|
end
|
|
end
|
|
|
|
#装備品個別管理用描画処理
|
|
if $kure_base_script[:SortOut]
|
|
draw_txt.push("耐久値減少無効") if item.protect_durable
|
|
draw_txt = [] if KURE::SortOut::BROKEN_FEATURE == 1 && item.broken?
|
|
end
|
|
|
|
return draw_txt
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 特徴の文字配列の呼び出し(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def call_effect_txt(item)
|
|
draw_txt = Array.new
|
|
#書きだし
|
|
item.effects.each do |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
|
|
draw_txt.push($data_states[effect.data_id].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
|
|
end
|
|
|
|
return draw_txt
|
|
end
|
|
end
|
|
|
|
|
|
#==============================================================================
|
|
# ●■ RPG::BaseItem(追加定義集積)
|
|
#==============================================================================
|
|
class RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴オブジェクトの配列取得（特徴コードを限定）(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_data(code)
|
|
features.select {|ft| ft.code == code }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴オブジェクトの配列取得（特徴コードとデータ ID を限定）(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_with_id_data(code, id)
|
|
features.select {|ft| ft.code == code && ft.data_id == id }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴値の総乗計算(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_pi_data(code, id)
|
|
features_with_id_data(code, id).inject(1.0) {|r, ft| r *= ft.value }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴値の総和計算（データ ID を指定）(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_sum_data(code, id)
|
|
features_with_id_data(code, id).inject(0.0) {|r, ft| r += ft.value }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴値の総和計算（データ ID は非指定）(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_sum_all_data(code)
|
|
features_data(code).inject(0.0) {|r, ft| r += ft.value }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 特徴の集合和計算(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def features_set_data(code)
|
|
features_data(code).inject([]) {|r, ft| r |= [ft.data_id] }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ●■ 記憶数増加の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def gain_max_memorize
|
|
cheak_note = @note
|
|
gain_max_memorize = 0
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<最大記憶数増加\s?(\d+)\s?>/)
|
|
gain_max_memorize += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
return gain_max_memorize
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ●■ 記憶容量増加の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def gain_memorize
|
|
cheak_note = @note
|
|
gain_memorize = 0
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<最大記憶容量増加\s?(\d+)\s?>/)
|
|
gain_memorize += $1.to_i if $1
|
|
cheak_note = $'
|
|
end
|
|
return gain_memorize
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ 経験済み職業クラスIDの定義(追加定義)[共用]
|
|
#--------------------------------------------------------------------------
|
|
def exp_jobchange_class
|
|
list = @note.scan(/<経験済職業\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ 転職可能アクターIDの定義(追加定義)[共用]
|
|
#--------------------------------------------------------------------------
|
|
def need_jobchange_actor
|
|
list = @note.scan(/<転職許可\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ リスト表示の定義(追加定義)[共用]
|
|
#--------------------------------------------------------------------------
|
|
def view_class_name
|
|
return false if @note.include?("<非公開表示>")
|
|
return true
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ 短縮職業名(追加定義)[共用]
|
|
#--------------------------------------------------------------------------
|
|
def short_class_name
|
|
@note.match(/<短縮名称\s?(.+?)\s?>/)
|
|
return @name unless $1
|
|
return $1
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ 記憶容量の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def memorize_capacity
|
|
@note.match(/<記憶容量\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ スキルの表示、非表示定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def view_skill_mode
|
|
return 0 if @note.include?("<常時非表示>")
|
|
return 1 if @note.include?("<戦闘中非表示>")
|
|
return 2 if @note.include?("<メニュー非表示>")
|
|
return 3
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■★ パッシブスキルの対応武器IDの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def passive_skill_id_w
|
|
list = @note.scan(/<パッシブ能力武器\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■★ パッシブスキルの対応防具IDの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def passive_skill_id_a
|
|
list = @note.scan(/<パッシブ能力防具\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■★ パッシブスキルの対応職業IDの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def passive_skill_id_c
|
|
list = @note.scan(/<パッシブ能力職業\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ メモライズ数の職業補正定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def max_memorize_revise
|
|
list = @note.scan(/<メモライズ数補正\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ 追加メモライズ数を保存している変数の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_max_memorize_var
|
|
list = @note.scan(/<追加メモライズ数保存変数\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ メモライズ容量の職業補正定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def memorize_capacity_revise
|
|
list = @note.scan(/<メモライズ容量補正\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ 追加メモライズ容量を保存している変数の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_max_memorize_cap_var
|
|
list = @note.scan(/<追加メモライズ容量保存変数\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ 初期メモライズ定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def first_memorize
|
|
list = @note.scan(/<初期メモライズ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ■ 共存不可メモライズ定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_jumble_memorize
|
|
list = @note.scan(/<共存不可メモライズ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ オートメモライズ不要の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_auto_memorize
|
|
return @note.include?("<自動メモライズ不要>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アクターの基本能力値を取得する職業IDの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def base_param_index
|
|
@note.match(/<基本能力値\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 職業別TP基本値の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def base_tp
|
|
@note.match(/<TP基本値\s?(\d+)\s?>/)
|
|
return 50 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 職業別TP上限値の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def upper_limit_tp
|
|
@note.match(/<TP上限値\s?(\d+)\s?>/)
|
|
return 9999 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アクター別TPのLv補正値の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def tp_level_revise
|
|
@note.match(/<TPLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
|
return 0 unless $1
|
|
value = $1.to_f
|
|
value += $2.to_f if $2
|
|
return value
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 通常攻撃に使用するスキルIDの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def normal_attack_id
|
|
list = @note.scan(/<通常攻撃\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 戦闘開始時のTP値の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def battle_start_tp
|
|
@note.match(/<開始時TP\s?(\d+)%>/)
|
|
return -1 unless $1
|
|
return 100 if $1.to_i > 100
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アクター追加能力(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def battler_add_ability(id)
|
|
return call_add_feature(id, @note)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ブースター能力(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def multi_booster(id)
|
|
return call_multi_booster(id, @note)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ パーティー追加能力(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def party_add_ability(id)
|
|
return call_party_add_feature(id, @note)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 複数属性の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def attack_elements_list
|
|
list = @note.scan(/<攻撃属性\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 属性反映の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def reflect_elements
|
|
return @note.include?("<攻撃属性スキル反映>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アビリティポイントの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def get_ability_point
|
|
list = @note.scan(/<習得AP\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 必要アビリティポイントの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def need_ability_point
|
|
@note.match(/<必要AP\s?(\d+)\s?>/)
|
|
return 1000 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ★ 追加スキルポイント数を保存している変数の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_max_skillpoint_var
|
|
@note.match(/<追加ポイント数保存変数\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ★ スキルポイントのアクター補正定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def skillpoint_revise
|
|
@note.match(/<スキルポイント補正\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ★ スキルポイントのLv補正定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def skillpoint_level_revise
|
|
@note.match(/<スキルポイントLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
|
return 0 unless $1
|
|
value = $1.to_f
|
|
value += $2.to_f if $2
|
|
return value
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ★ スキルポイントのJobLv補正定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def skillpoint_joblevel_revise
|
|
@note.match(/<スキルポイントJobLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
|
return 0 unless $1
|
|
value = $1.to_f
|
|
value += $2.to_f if $2
|
|
return value
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 死亡時残留ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_delete_state
|
|
return @note.include?("<死亡時残留>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 全回復残留ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_delete_state_healing
|
|
return @note.include?("<全回復時残留>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ドロップ率増加の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def gain_drop_rate
|
|
@note.match(/<ドロップ変化\s?(\d+)%\s?>/)
|
|
return 100 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◆ 破損状態の取得
|
|
#--------------------------------------------------------------------------
|
|
def broken?
|
|
false
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::UsableItem(追加定義)
|
|
#==============================================================================
|
|
class RPG::UsableItem < RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 耐久値ダメージ、回復の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def durable_damage
|
|
durable_damage = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<耐久値ダメージ\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2 && $3
|
|
durable_damage.push([$1.to_i, $2.to_i, $3.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
|
|
cheak_note = @note if @note
|
|
while cheak_note do
|
|
cheak_note.match(/<耐久値回復\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
durable_damage.push([$1.to_i, -1 * ($2.to_i), 100])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
|
|
return durable_damage
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 連続回数の定義(再定義)
|
|
#--------------------------------------------------------------------------
|
|
def repeats
|
|
@note.match(/<連続回数\s?(\d+)\s?>/)
|
|
return @repeats unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 使用効果の定義(再定義)
|
|
#--------------------------------------------------------------------------
|
|
def effects
|
|
effect = add_effects_before
|
|
effect += @effects.clone
|
|
effect += add_effects_after
|
|
return effect
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 使用効果の追加定義[基本より前の処理](追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_effects_before
|
|
add_effect = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
#ステート初期化のメモ欄設定適用
|
|
cheak_note.match(/<ステート初期化\s?(\d+)%\s?>/)
|
|
if $1
|
|
add_effect.push(RPG::UsableItem::Effect.new(49, $1.to_i))
|
|
end
|
|
|
|
return add_effect
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 使用効果の追加定義[基本より後の処理](追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_effects_after
|
|
add_effect = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
#盗むのメモ欄設定適用
|
|
cheak_note.match(/<スティール付与\s?(\d+)\s?>/)
|
|
if $1
|
|
add_effect.push(RPG::UsableItem::Effect.new(45, $1.to_i))
|
|
end
|
|
|
|
#スキルポイントリセットのメモ欄設定適用
|
|
if cheak_note.include?("<スキルポイントリセット>")
|
|
add_effect.push(RPG::UsableItem::Effect.new(46))
|
|
end
|
|
|
|
#装備破壊のメモ欄設定適用
|
|
cheak_note.match(/<耐久値ダメージ\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2 && $3
|
|
add_effect.push(RPG::UsableItem::Effect.new(47))
|
|
end
|
|
|
|
#耐久力回復のメモ欄設定適用
|
|
cheak_note.match(/<耐久値回復\s?(\d+)\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
add_effect.push(RPG::UsableItem::Effect.new(47))
|
|
end
|
|
|
|
#アイテム獲得のメモ欄設定適用
|
|
cheak_note.match(/<獲得アイテム\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
if $1
|
|
add_effect.push(RPG::UsableItem::Effect.new(48))
|
|
end
|
|
|
|
return add_effect
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 回復反転無視スキルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def ignore_reverse_heel
|
|
return @note.include?("<回復反転無視>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 連続発動スキルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def multi_skill_effect
|
|
list = @note.scan(/<連続発動スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 連続アニメーションの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def multi_anim_effect
|
|
list = @note.scan(/<連続アニメーション\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 仲間想い補正の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def companion_revise
|
|
@note.match(/<仲間想い\s?(\d+)%\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 武器倍率の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def weapon_d_rate
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
list = cheak_note.scan(/<武器倍率\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
save_list = Array.new
|
|
weapon_rate = Array.new
|
|
|
|
return weapon_rate if list == [] and list.empty?
|
|
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
|
|
|
return arr_id_value_flatten(save_list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ エラー回避(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def is_skill?
|
|
return false
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 通常攻撃スキルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def normal_attack_skill?
|
|
return @note.include?("<通常攻撃判定>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ステート反撃対象の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_counter_state?
|
|
return @note.include?("<ステート反撃対象>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 初期化ステートタイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def clear_state_type
|
|
list = @note.scan(/<初期化ステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 初期化対象外ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_clear_state_type
|
|
list = @note.scan(/<ステート初期化対象外\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 発動後ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def after_add_state
|
|
list = @note.scan(/<発動後付与ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::Skill(再定義)
|
|
#==============================================================================
|
|
class RPG::Skill < RPG::UsableItem
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 獲得アイテムの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def get_item_list
|
|
list = @note.scan(/<獲得アイテム\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
|
return arr_id_value_pack(list, 2)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 必要武器タイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def required_add_wtype_id
|
|
list = @note.scan(/<必要武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 要求装備タイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def need_etype_id
|
|
list = @note.scan(/<要求装備タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 要求武器タイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def need_wtype_id_all
|
|
list = @note.scan(/<要求武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 二刀流スキルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def need_two_weapon
|
|
return @note.include?("<二刀流要求>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 二刀流同一ID要求の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def request_same_weapon_id
|
|
return @note.include?("<同一タイプ二刀流専用>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ エラー回避(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def is_skill?
|
|
return true
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 発動条件の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def passive_condition_list(id)
|
|
case id
|
|
when 0
|
|
#発動要求武器
|
|
list = @note.scan(/<発動要求武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
when 1
|
|
#発動要求防具
|
|
list = @note.scan(/<発動要求装備タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
return []
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 耐久値減少の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def reduce_durable
|
|
reduce_durable = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<耐久値消費\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)%\s?>/)
|
|
if $1 && $2 && $3
|
|
reduce_durable.push([$1.to_i, $2.to_i, $3.to_i])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
return reduce_durable
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 習得不可の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def not_learn_list
|
|
list = @note.scan(/<習得不可\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::EquipItem(再定義)
|
|
#==============================================================================
|
|
class RPG::EquipItem < RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ● 装備タイプの定義(再定義)
|
|
#--------------------------------------------------------------------------
|
|
def etype_id
|
|
@note.match(/<装備タイプ\s?(\d+)\s?>/)
|
|
return @etype_id unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 拡張装備タイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_etype_id
|
|
list = @note.scan(/<拡張装備タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 装備可能アクターの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def actor_equip_limit
|
|
list = @note.scan(/<装備可能アクター\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ● 装備タイプの定義(再定義)
|
|
#--------------------------------------------------------------------------
|
|
def etype_id=(etype_id)
|
|
@etype_id = etype_id
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::Actor(追加定義)
|
|
#==============================================================================
|
|
class RPG::Actor < RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ◇ 初期ジョブレベルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def initial_joblevel
|
|
@note.match(/<初期職業レベル\s?(\d+)\s?>/)
|
|
return 1 unless $1
|
|
return $1.to_i
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::Enemy(追加定義)
|
|
#==============================================================================
|
|
class RPG::Enemy < RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ◇ 装備経験値の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def equip_exp
|
|
@note.match(/<装備Exp\s?(\d+)\s?>/)
|
|
return @exp unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ アビリティポイントの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def ability_exp
|
|
@note.match(/<獲得AP\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# § ステータスポイントの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def status_exp
|
|
@note.match(/<ステータスポイント\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# § スキルポイントの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def skill_exp
|
|
@note.match(/<スキルポイント\s?(\d+)\s?>/)
|
|
return 0 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ◇ レベルの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def level
|
|
@note.match(/<レベル\s?(\d+)\s?>/)
|
|
return 1 unless $1
|
|
return $1.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ドロップアイテムの定義(再定義)
|
|
#--------------------------------------------------------------------------
|
|
def drop_items
|
|
add_drop_items unless @add_drop_items
|
|
return @drop_items + @add_drop_items if @add_drop_items
|
|
return @drop_items
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 追加ドロップアイテムの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def add_drop_items
|
|
@add_drop_items = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<追加ドロップ\s?([IWA])\s?,\s?(\d+)\s?,\s?(\d+)>/)
|
|
if $1 && $2 && $3
|
|
new_drop = RPG::Enemy::DropItem.new
|
|
case $1.upcase
|
|
when "I"
|
|
new_drop.kind = 1
|
|
when "W"
|
|
new_drop.kind = 2
|
|
when "A"
|
|
new_drop.kind = 3
|
|
end
|
|
new_drop.data_id = $2.to_i
|
|
new_drop.denominator = $3.to_f
|
|
|
|
@add_drop_items.push(new_drop)
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 盗めるアイテムの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def steal_list
|
|
steal_list = Array.new
|
|
cheak_note = ""
|
|
cheak_note = @note if @note
|
|
|
|
while cheak_note do
|
|
cheak_note.match(/<スティールリスト\s?(\d+)\s?,\s?([IWA])\s?,\s?(\d+)\s?,\s?(\d+)>/)
|
|
if $1 && $2 && $3 && $4
|
|
case $2.upcase
|
|
when "I"
|
|
kind = 1
|
|
when "W"
|
|
kind = 2
|
|
when "A"
|
|
kind = 3
|
|
end
|
|
data_id = $3.to_i
|
|
denominator = $4.to_f
|
|
|
|
steal_list[$1.to_i] ||= []
|
|
steal_list[$1.to_i].push([kind, data_id, denominator])
|
|
end
|
|
cheak_note = $'
|
|
end
|
|
|
|
return steal_list
|
|
end
|
|
end
|
|
|
|
#==============================================================================
|
|
# ■ RPG::State(追加定義)
|
|
#==============================================================================
|
|
class RPG::State < RPG::BaseItem
|
|
#--------------------------------------------------------------------------
|
|
# ☆身代わり対象設定の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def adv_substitute_t
|
|
return @note.include?("<身代わり対象設定>")
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆重複許容の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def multi_addable
|
|
result = nil
|
|
@note.match(/<重複許容\s?([AEB])\s?,\s?(\d+)\s?>/)
|
|
if $1 && $2
|
|
result = []
|
|
case $1.upcase
|
|
when "A"
|
|
result[0] = 0
|
|
when "E"
|
|
result[0] = 1
|
|
when "B"
|
|
result[0] = 2
|
|
end
|
|
result[1] = $2.to_i
|
|
end
|
|
return result
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ステートタイプの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def state_type
|
|
list = @note.scan(/<ステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ ステート解除時付与の定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def next_state
|
|
list = @note.scan(/<解除時ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 前提ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def basic_state
|
|
list = @note.scan(/<前提ステート\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 相殺ステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def offset_state_type
|
|
list = @note.scan(/<相殺ステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆ 上書きステートの定義(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def overwrite_state_type
|
|
list = @note.scan(/<上書きステートタイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
|
return arr_num_slice(list)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆上書きの定義(追加定義)(追加定義)
|
|
#--------------------------------------------------------------------------
|
|
def overwrite_mode
|
|
return 1 if @note.include?("<効果延長>")
|
|
return 2 if @note.include?("<効果上書き不可>")
|
|
return 0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# ☆反射先の定義(追加定義)(未実装)
|
|
#--------------------------------------------------------------------------
|
|
def mirror_mode
|
|
return 1 if @note.include?("<敵単体反射>")
|
|
return 2 if @note.include?("<敵全体反射>")
|
|
return 3 if @note.include?("<味方単体反射>")
|
|
return 4 if @note.include?("<味方全体反射>")
|
|
return 0
|
|
end
|
|
end |