3546 lines
No EOL
141 KiB
Ruby
3546 lines
No EOL
141 KiB
Ruby
|
||
|
||
#==============================================================================
|
||
# ■併用化ベーススクリプト for RGSS3 Ver1.38-β9
|
||
# □author kure
|
||
#
|
||
# 併用化対応スクリプト
|
||
# ●装備拡張 Ver1.12以降
|
||
# ■スキルメモライズシステム Ver1.10以降
|
||
# ★スキルポイントシステム Ver1.00以降
|
||
# ▲職業レベル Ver1.03以降
|
||
# ◆転職画面 Ver2.00以降
|
||
# ◎拡張ステータス画面Ver1.10以降
|
||
# ☆拡張機能集積Ver1.03以降
|
||
# ◇装備品個別管理Ver0.50以降
|
||
#
|
||
#==============================================================================
|
||
module KURE
|
||
module BaseScript
|
||
#併用スクリプト設定---------------------------------------------------------
|
||
#装備拡張(0=併用しない 1=併用する)------------------------------------------
|
||
USE_ExEquip = 0
|
||
|
||
#スキルメモライズシステム(0=併用しない 1=併用する)--------------------------
|
||
USE_Skill_Memorize = 0
|
||
|
||
#スキルポイントシステム(0=併用しない 1=併用する)----------------------------
|
||
USE_Skill_Point = 1
|
||
|
||
#職業レベル(0=併用しない 1=併用する)----------------------------------------
|
||
USE_JOBLv = 0
|
||
|
||
#転職画面(0=併用しない 1=併用する)------------------------------------------
|
||
USE_JobChange = 0
|
||
|
||
#拡張ステータス画面(0=併用しない 1=併用する)--------------------------------
|
||
USE_ExStatus = 1
|
||
|
||
#PT編成画面(0=併用しない 1=併用する)----------------------------------------
|
||
USE_PartyEdit = 0
|
||
|
||
#装備品個別管理(0=併用しない 1=併用する)
|
||
USE_SortOut = 0
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ▲ Vocab(追加定義)
|
||
#==============================================================================
|
||
module Vocab
|
||
ObtainJobExp = "Gained %s's job experience!"
|
||
ObtainEquipExp = "Gained %s's equipment experience!"
|
||
ObtainAP = "Gained %s's ability points!"
|
||
|
||
EnemySteal = "%s's %s Stolen!"
|
||
EnemyNOSteal = "Couldn't steal anything from %s!"
|
||
EnemyStealed = "%s doesn't have anything!"
|
||
|
||
PayLife = "%s has fallen!"
|
||
Revive = "%s has gotten back up!"
|
||
Stand = "%s held their ground!"
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_Base
|
||
#==============================================================================
|
||
class Window_Base < Window
|
||
#--------------------------------------------------------------------------
|
||
# ▲ レベルの描画(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def draw_actor_level(actor, x, y)
|
||
change_color(system_color)
|
||
draw_text(x, y, 24, line_height, Vocab::level_a)
|
||
change_color(normal_color)
|
||
draw_text(x + 24, y, 24, line_height, actor.level, 2)
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if actor.max_joblevel != 1
|
||
draw_text(x + 48, y, 10, line_height, "/", 2)
|
||
draw_text(x + 58, y, 24, line_height, actor.joblevel, 2)
|
||
end
|
||
if actor.sub_class_id != 0
|
||
draw_text(x + 82, y, 10, line_height, "/", 2)
|
||
draw_text(x + 92, y, 24, line_height, actor.sub_class_level, 2)
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●■★▲◆ 職業の描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_actor_class(actor, x, y, width = 130)
|
||
change_color(normal_color)
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if actor.sub_class_id != 0
|
||
draw_text(x, y, 60, line_height, actor.class.short_class_name,1)
|
||
draw_text(x + 60, y, 10, line_height, "/",1)
|
||
draw_text(x + 70, y, 60, line_height, actor.sub_class.short_class_name,1)
|
||
else
|
||
draw_text(x, y, width, line_height, actor.class.name)
|
||
end
|
||
else
|
||
draw_text(x, y, width, line_height, actor.class.name)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP の描画(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def draw_actor_tp(actor, x, y, width = 124)
|
||
return if actor.max_tp == 0
|
||
draw_gauge(x, y, width, actor.tp_rate, tp_gauge_color1, tp_gauge_color2)
|
||
change_color(system_color)
|
||
draw_text(x, y, 30, line_height, Vocab::tp_a)
|
||
change_color(tp_color(actor))
|
||
contents.font.size = 16
|
||
draw_current_and_max_values(x, y, width, actor.tp.to_i, actor.max_tp.to_i,
|
||
tp_color(actor), normal_color)
|
||
contents.font.size = 22
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◎ 経験値情報の描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_exp_info(x, y)
|
||
s1 = @actor.max_level? ? "-------" : @actor.next_level_exp - @actor.exp
|
||
s2 = @actor.max_joblevel? ? "-------" : @actor.next_joblevel_exp - @actor.jobexp if KURE::BaseScript::USE_JobChange == 1
|
||
s_next = "Next"
|
||
change_color(system_color)
|
||
if KURE::BaseScript::USE_JobChange == 1
|
||
draw_text(x, y , 40, line_height, s_next)
|
||
change_color(tp_gauge_color2)
|
||
draw_text(x + 40, y , 40, line_height, "Base")
|
||
change_color(normal_color)
|
||
draw_text(x + 80, y , 65, line_height, s1, 2)
|
||
draw_text(x + 145, y , 10, line_height, "/", 2)
|
||
change_color(mp_gauge_color2)
|
||
draw_text(x + 155, y , 30, line_height, "Job")
|
||
change_color(normal_color)
|
||
draw_text(x + 185, y , 60, line_height, s2, 2)
|
||
else
|
||
draw_text(x + 100, y , 45, line_height, s_next)
|
||
change_color(normal_color)
|
||
draw_text(x + 140, y , 85, line_height, s1, 2)
|
||
end
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_SkillList(再定義)
|
||
#==============================================================================
|
||
class Window_SkillList < Window_Selectable
|
||
#--------------------------------------------------------------------------
|
||
# ● 記憶スキルリストの作成(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def make_item_list
|
||
|
||
#戦闘中と非戦闘中で処理を分岐する
|
||
if $game_party.in_battle
|
||
#メモライズ適用時の処理(戦闘中は常に適用)
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
@data = @actor ? @actor.skills.select {|skill| include?(skill) && view_skill_b?(skill) && (@actor.memory_skills.include?(skill) or @actor.extra_skills.include?(skill) or @actor.unselect_skill?(skill.id))} : []
|
||
else
|
||
@data = @actor ? @actor.skills.select {|skill| include?(skill) && view_skill_b?(skill)} : []
|
||
end
|
||
else
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
if KURE::SkillMemorize::ADOPT_MEMORIZE == 0
|
||
@data = @actor ? @actor.skills.select {|skill| include?(skill) && view_skill_f?(skill) && (@actor.memory_skills.include?(skill) or @actor.extra_skills.include?(skill) or @actor.unselect_skill?(skill.id))} : []
|
||
else
|
||
@data = @actor ? @actor.skills.select {|skill| include?(skill) && view_skill_f?(skill) } : []
|
||
end
|
||
else
|
||
@data = @actor ? @actor.skills.select {|skill| include?(skill) && view_skill_f?(skill) } : []
|
||
end
|
||
end
|
||
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルを表示するかどうか
|
||
#--------------------------------------------------------------------------
|
||
def view_skill_b?(item)
|
||
item && (item.view_skill_mode == 2 or item.view_skill_mode == 3)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルを表示するかどうか
|
||
#--------------------------------------------------------------------------
|
||
def view_skill_f?(item)
|
||
item && (item.view_skill_mode == 3 or item.view_skill_mode == 1)
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_BattleLog
|
||
#==============================================================================
|
||
class Window_BattleLog < Window_Selectable
|
||
#--------------------------------------------------------------------------
|
||
# ● 行動結果の表示
|
||
#--------------------------------------------------------------------------
|
||
def display_action_results(target, item)
|
||
if target.result.used
|
||
last_line_number = line_number
|
||
display_critical(target, item)
|
||
display_damage(target, item)
|
||
display_autostand_message(target)
|
||
display_steal(target, item)
|
||
display_affected_status(target, item)
|
||
display_failure(target, item)
|
||
wait if line_number > last_line_number
|
||
back_to(last_line_number)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スティールの表示
|
||
#--------------------------------------------------------------------------
|
||
def display_steal(target, item)
|
||
if target.enemy?
|
||
if target.result.use_steal
|
||
|
||
if target.result.stealed
|
||
fmt = Vocab::EnemyStealed
|
||
add_text(sprintf(fmt, target.name))
|
||
#$game_message.add(sprintf(fmt, target.name))
|
||
elsif target.result.steal
|
||
fmt = Vocab::EnemySteal
|
||
add_text(sprintf(fmt, target.name, target.result.steal.name))
|
||
# $game_message.add(sprintf(fmt, target.name, target.result.steal.name))
|
||
else
|
||
fmt = Vocab::EnemyNOSteal
|
||
add_text(sprintf(fmt, target.name))
|
||
Audio.se_play("Audio/SE/Sword2", $game_system.m_v[3], 80)#紅茶走
|
||
end
|
||
target.result.success = true
|
||
wait
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自爆スキルのメッセージの表示
|
||
#--------------------------------------------------------------------------
|
||
def display_paylife_message(user, item)
|
||
if item.is_a?(RPG::Skill) && item.life_cost
|
||
fmt = Vocab::PayLife
|
||
add_text(sprintf(fmt, user.name))
|
||
wait
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● オートリザレクションのメッセージの表示
|
||
#--------------------------------------------------------------------------
|
||
def display_autorevive_message(battler)
|
||
return if battler.hp != 0
|
||
fmt = Vocab::Revive
|
||
add_text(sprintf(fmt, battler.name))
|
||
wait
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 踏みとどまりのメッセージの表示
|
||
#--------------------------------------------------------------------------
|
||
def display_autostand_message(battler)
|
||
return unless battler.result.auto_stand
|
||
fmt = Vocab::Stand
|
||
add_text(sprintf(fmt, battler.name))
|
||
wait
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ●■ RPG::BaseItem(追加定義集積)
|
||
#==============================================================================
|
||
class RPG::BaseItem
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備封印の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def seal_equip_type
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<装備封印\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備固定の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def rock_equip_type
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<装備固定\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備重量の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def weight
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備重量\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 最大重量補正の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def weight_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大重量補正\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備重量増加の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_weight
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大重量増加\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●■ 記憶数増加の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_max_memorize
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大記憶数増加\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●■ 記憶容量増加の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_memorize
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大記憶容量増加\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備レベルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_equip_level
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備要求レベル\s?(\d+)>/)
|
||
return 1 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●▲ 装備職業レベルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_equip_joblevel
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備要求職業レベル\s?(\d+)>/)
|
||
return 1 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●▲ 装備要求変数の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_equip_val
|
||
request_val = Array.new
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備要求変数\s?(\d+),\s?(\d+)>/)
|
||
request_val[0] = 0
|
||
request_val[1] = 0
|
||
request_val[0] = $1.to_i if $1 != nil
|
||
request_val[1] = $2.to_i if $2 != nil
|
||
return request_val
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備ステータスの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_equip_status
|
||
need_status = Array.new
|
||
cheack_note = @note
|
||
|
||
#最大HP
|
||
cheack_note.match(/<装備要求HP\s?(\d+)>/)
|
||
need_status[0] = 0
|
||
need_status[0] = $1.to_i if $1 != nil
|
||
|
||
#最大MP
|
||
cheack_note.match(/<装備要求MP\s?(\d+)>/)
|
||
need_status[1] = 0
|
||
need_status[1] = $1.to_i if $1 != nil
|
||
|
||
#攻撃力
|
||
cheack_note.match(/<装備要求攻撃力\s?(\d+)>/)
|
||
need_status[2] = 0
|
||
need_status[2] = $1.to_i if $1 != nil
|
||
|
||
#防御力
|
||
cheack_note.match(/<装備要求防御力\s?(\d+)>/)
|
||
need_status[3] = 0
|
||
need_status[3] = $1.to_i if $1 != nil
|
||
|
||
#魔法力
|
||
cheack_note.match(/<装備要求魔法力\s?(\d+)>/)
|
||
need_status[4] = 0
|
||
need_status[4] = $1.to_i if $1 != nil
|
||
|
||
#魔法防御力
|
||
cheack_note.match(/<装備要求魔法防御力\s?(\d+)>/)
|
||
need_status[5] = 0
|
||
need_status[5] = $1.to_i if $1 != nil
|
||
|
||
#敏捷性
|
||
cheack_note.match(/<装備要求敏捷性\s?(\d+)>/)
|
||
need_status[6] = 0
|
||
need_status[6] = $1.to_i if $1 != nil
|
||
|
||
#運
|
||
cheack_note.match(/<装備要求運\s?(\d+)>/)
|
||
need_status[7] = 0
|
||
need_status[7] = $1.to_i if $1 != nil
|
||
return need_status
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 使用する経験値曲線の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def use_exp_curve
|
||
cheack_note = @note
|
||
cheack_note.match(/<経験値曲線\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 最大職業レベル定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def max_job_level_value
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大職業Lv\s?(\d+)>/)
|
||
return 99 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ アクター固有習得スキルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def actor_peculiar_skill
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<固有習得\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 初期サブクラスの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def first_sub_class
|
||
cheack_note = @note
|
||
cheack_note.match(/<初期サブクラス\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 適用外特徴の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def not_applied_features
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<適用外特徴\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 適用外特徴(指定DATAID)の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def not_applied_features_data
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<適用外特徴データ\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 職業ランクの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def class_lank
|
||
cheack_note = @note
|
||
cheack_note.match(/<職業ランク\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職レベルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_level
|
||
request_lv = Array.new
|
||
cheack_note = @note
|
||
cheack_note.match(/<転職レベル\s?(\d+),\s?(\d+)>/)
|
||
request_lv[0] = 0
|
||
request_lv[1] = 0
|
||
request_lv[0] = $1.to_i if $1 != nil
|
||
request_lv[1] = $2.to_i if $2 != nil
|
||
return request_lv
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 要求経験職クラスIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_class
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<要求経験職\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 選択経験職クラスIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def select_jobchange_class
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<選択経験職\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 要求未経験職クラスIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def unless_need_jobchange_class
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<要求未経験職\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 両立不可職クラスIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def not_same_time_jobchange_class
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<両立不可職\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 経験済み職業クラスIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def exp_jobchange_class
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<経験済職業\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職可能アクターIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_actor
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<転職許可\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職要求スキルIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_skill
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<転職スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職要求スイッチIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_swith
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<転職スイッチ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職要求アイテムIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_jobchange_item
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<転職アイテム\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ リスト表示の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def view_class_name
|
||
cheack_note = @note
|
||
return false if cheack_note.include?("<非公開表示>")
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ サブクラス封印の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def seal_sub_class
|
||
cheack_note = @note
|
||
return true if cheack_note.include?("<サブクラス封印>")
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ メイン、サブ専用クラス定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def change_class_kind
|
||
cheack_note = @note
|
||
return 0 if cheack_note.include?("<サブクラス専用職>")
|
||
return 1 if cheack_note.include?("<メインクラス専用職>")
|
||
return 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ グラフィック変更許可(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def can_change_graphic
|
||
cheack_note = @note
|
||
cheack_note.match(/<グラフィック変更許可\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 短縮職業名(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def short_class_name
|
||
cheack_note = @note
|
||
cheack_note.match(/<短縮名称\s?(.+?)>/)
|
||
return @name if $1 == nil
|
||
return $1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職時グラフィック設定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def use_job_graphic
|
||
graphic = Array.new
|
||
graphic = [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]]
|
||
cheack_note = @note
|
||
for i in 0..3
|
||
if cheack_note
|
||
cheack_note.match(/<使用グラフィック(\d+)\s?(.+?),\s?(\d+),\s?(.+?),\s?(\d+)>/)
|
||
graphic[i][0] = $1.to_i if $1 != nil
|
||
graphic[i][1] = $2 if $2 != nil
|
||
graphic[i][2] = $3.to_i if $3 != nil
|
||
graphic[i][3] = $4 if $4 != nil
|
||
graphic[i][4] = $5.to_i if $5 != nil
|
||
cheack_note = $'
|
||
end
|
||
end
|
||
return graphic
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職画面追加の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_jobchange_window
|
||
cheack_note = @note
|
||
cheack_note.match(/<転職画面許可\s?(\d+)>/)
|
||
return -1 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ 転職画面表示の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def view_jobchange_window
|
||
cheack_note = @note
|
||
cheack_note.match(/<転職画面表示\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 記憶容量の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def memorize_capacity
|
||
cheack_note = @note
|
||
cheack_note.match(/<記憶容量\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ スキルの表示、非表示定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def view_skill_mode
|
||
cheack_note = @note
|
||
return 0 if cheack_note.include?("<常時非表示>")
|
||
return 1 if cheack_note.include?("<戦闘中非表示>")
|
||
return 2 if cheack_note.include?("<メニュー非表示>")
|
||
return 3
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ パッシブスキルの対応武器IDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def passive_skill_id_w
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<パッシブ能力武器\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ パッシブスキルの対応防具IDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def passive_skill_id_a
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<パッシブ能力防具\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ パッシブスキルの対応職業IDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def passive_skill_id_c
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<パッシブ能力職業\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ メモライズ数の職業補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def max_memorize_revise
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<メモライズ数補正\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 追加メモライズ数を保存している変数の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_max_memorize_var
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<追加メモライズ数保存変数\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ メモライズ容量の職業補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def memorize_capacity_revise
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<メモライズ容量補正\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 追加メモライズ容量を保存している変数の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_max_memorize_cap_var
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<追加メモライズ容量保存変数\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 初期メモライズ定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def first_memorize
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<初期メモライズ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 共存不可メモライズ定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def not_jumble_memorize
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<共存不可メモライズ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◆ オートメモライズ不要の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def not_auto_memorize
|
||
cheack_note = @note
|
||
return true if cheack_note.include?("<自動メモライズ不要>")
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ アクターの基本能力値を取得する職業IDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def base_param_index
|
||
cheack_note = @note
|
||
cheack_note.match(/<基本能力値\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 職業別TP基本値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def base_tp
|
||
cheack_note = @note
|
||
cheack_note.match(/<TP基本値\s?(\d+)>/)
|
||
return 50 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 職業別TP上限値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def upper_limit_tp
|
||
cheack_note = @note
|
||
cheack_note.match(/<TP上限値\s?(\d+)>/)
|
||
return 9999 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ アクター別TPのLv補正値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def tp_level_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<TPLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
||
return 0 if $1 == nil
|
||
value = $1.to_f
|
||
value += $2.to_f if $2
|
||
return value
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 通常攻撃に使用するスキルIDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def normal_attack_id
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<通常攻撃\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 装備のTP補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_tp
|
||
gain_tp = Array.new
|
||
cheack_note = @note
|
||
cheack_note.match(/<最大TP増加\s?(\d+)([%])?>/)
|
||
gain_tp[0] = 0
|
||
gain_tp[1] = 0
|
||
gain_tp[0] = $1.to_i if $1 != nil
|
||
gain_tp[1] = 1 if $2 != nil
|
||
return gain_tp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 戦闘開始時のTP値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def battle_start_tp
|
||
cheack_note = @note
|
||
cheack_note.match(/<開始時TP\s?(\d+)%>/)
|
||
return 0 if $1 == nil
|
||
return 100 if $1.to_i > 100
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ パーティー追加能力(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def party_add_ability
|
||
party_add = Array.new
|
||
cheack_note = @note
|
||
|
||
#獲得金額倍率設定
|
||
cheack_note.match(/<獲得金額倍率\s?(\d+)%>/)
|
||
party_add[0] = 100
|
||
party_add[0] = $1.to_i if $1 != nil
|
||
|
||
#アイテムドロップ率の設定
|
||
cheack_note.match(/<獲得アイテム倍率\s?(\d+)%>/)
|
||
party_add[1] = 100
|
||
party_add[1] = $1.to_i if $1 != nil
|
||
|
||
#エンカウント率の設定
|
||
cheack_note.match(/<エンカウント倍率\s?(\d+)%>/)
|
||
party_add[2] = 100
|
||
party_add[2] = $1.to_i if $1 != nil
|
||
|
||
#獲得経験値倍率の設定
|
||
cheack_note.match(/<獲得経験値倍率\s?(\d+)%>/)
|
||
party_add[3] = 100
|
||
party_add[3] = $1.to_i if $1 != nil
|
||
|
||
#獲得職業経験値倍率の設定
|
||
cheack_note.match(/<獲得職業経験値倍率\s?(\d+)%>/)
|
||
party_add[4] = 100
|
||
party_add[4] = $1.to_i if $1 != nil
|
||
|
||
#獲得職業経験値倍率の設定
|
||
cheack_note.match(/<獲得装備経験値倍率\s?(\d+)%>/)
|
||
party_add[5] = 100
|
||
party_add[5] = $1.to_i if $1 != nil
|
||
|
||
return party_add
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アクター追加能力(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def battler_add_ability
|
||
battler_add = Array.new
|
||
cheack_note = @note
|
||
|
||
#獲得金額倍率設定
|
||
cheack_note.match(/<スティール成功率\s?(\d+)%>/)
|
||
battler_add[0] = 100
|
||
battler_add[0] = $1.to_i if $1 != nil
|
||
|
||
#オートリザレクション
|
||
cheack_note.match(/<オートリザレクション\s?(\d+)%>/)
|
||
battler_add[1] = 0
|
||
battler_add[1] = $1.to_i if $1
|
||
|
||
#踏みとどまり
|
||
cheack_note.match(/<踏みとどまり\s?(\d+)%>/)
|
||
battler_add[2] = 0
|
||
battler_add[2] = $1.to_i if $1
|
||
|
||
#回復反転
|
||
cheack_note.match(/<回復反転\s?(\d+)%>/)
|
||
battler_add[3] = 0
|
||
battler_add[3] = $1.to_i if $1
|
||
|
||
return battler_add
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ブースターの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def multi_booster
|
||
cheack_note = @note
|
||
#属性ブースター
|
||
list = cheack_note.scan(/<属性強化\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
e_booster = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| e_booster.push(num.to_i)}
|
||
end
|
||
|
||
#属性吸収
|
||
list = cheack_note.scan(/<属性吸収\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
e_drain = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| e_drain.push(num.to_i)}
|
||
end
|
||
|
||
#武器ブースター
|
||
list = cheack_note.scan(/<武器強化物理\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
ebp = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| ebp.push(num.to_i)}
|
||
end
|
||
|
||
list = cheack_note.scan(/<武器強化魔法\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
ebm = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| ebm.push(num.to_i)}
|
||
end
|
||
|
||
list = cheack_note.scan(/<武器強化必中\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
ebh = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| ebm.push(num.to_i)}
|
||
end
|
||
|
||
save_list = [e_booster, e_drain, ebp, ebm, ebh]
|
||
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 複数属性の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def attack_elements_list
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<攻撃属性\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 属性反映の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def reflect_elements
|
||
cheack_note = @note
|
||
return true if cheack_note.include?("<攻撃属性スキル反映>")
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アビリティポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def get_ability_point
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<習得AP\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 必要アビリティポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_ability_point
|
||
cheack_note = @note
|
||
cheack_note.match(/<必要AP\s?(\d+)>/)
|
||
return 1000 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◇ 強化上限の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_plus_limit
|
||
cheack_note = @note
|
||
cheack_note.match(/<強化上限\s?(\d+)>/)
|
||
return 10 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◇ 強化するパラメータの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def reinforce_param
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<強化パラメータ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
8.times{|i|save_list.push(i)} if save_list == ([] or empty?)
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◇ 強化補正上限の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_plus_revise_limit
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<強化補正上限\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
(8 - save_list.size).times{|i|save_list.push(10)}
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◇ 強化補正値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_plus_revise_all
|
||
cheack_note = @note
|
||
cheack_note.match(/<強化全補正\s?(\d+)>/)
|
||
return 1 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ◇ 強化補正値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_plus_revise
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<強化補正\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
(8 - save_list.size).times{|i|save_list.push(1)}
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ★ 追加スキルポイント数を保存している変数の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_max_skillpoint_var
|
||
cheack_note = @note
|
||
cheack_note.match(/<追加ポイント数保存変数\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ★ スキルポイントのアクター補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skillpoint_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<スキルポイント補正\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ★ スキルポイントのLv補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skillpoint_level_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<スキルポイントLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
||
return 0 if $1 == nil
|
||
value = $1.to_f
|
||
value += $2.to_f if $2
|
||
return value
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ★ スキルポイントのJobLv補正定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skillpoint_joblevel_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<スキルポイントJobLv補正\s?([1-9]\d*|0)(\.\d+)?>/)
|
||
return 0 if $1 == nil
|
||
value = $1.to_f
|
||
value += $2.to_f if $2
|
||
return value
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ RPG::UsableItem(追加定義)
|
||
#==============================================================================
|
||
class RPG::UsableItem < RPG::BaseItem
|
||
#--------------------------------------------------------------------------
|
||
# ● 使用効果の定義(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def effects
|
||
effect = @effects.clone
|
||
effect += add_effects
|
||
return effect
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 使用効果の追加定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def add_effects
|
||
add_effect = Array.new
|
||
cheack_note = @note
|
||
|
||
#盗むのメモ欄設定適用
|
||
cheack_note.match(/<スティール付与\s?(\d+)>/)
|
||
if $1
|
||
add_effect.push(RPG::UsableItem::Effect.new(45, $1.to_i))
|
||
end
|
||
|
||
#スキルポイントリセットのメモ欄設定適用
|
||
if cheack_note.include?("<スキルポイントリセット>")
|
||
add_effect.push(RPG::UsableItem::Effect.new(46))
|
||
end
|
||
|
||
return add_effect
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 発動スキルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def random_skill_effect
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<発動スキル\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 発動アイテムの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def random_item_effect
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<発動アイテム\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 仲間想い補正の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def companion_revise
|
||
cheack_note = @note
|
||
cheack_note.match(/<仲間想い\s?(\d+)%>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器倍率の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def weapon_d_rate
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_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)}
|
||
|
||
for list in 0..save_list.size - 1
|
||
if list % 2 == 0
|
||
if save_list[list] && save_list[list + 1]
|
||
weapon_rate[save_list[list]] = 0 unless weapon_rate[save_list[list]]
|
||
weapon_rate[save_list[list]] = save_list[list + 1]
|
||
end
|
||
end
|
||
end
|
||
|
||
return weapon_rate
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ RPG::Skill(再定義)
|
||
#==============================================================================
|
||
class RPG::Skill < RPG::UsableItem
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費TPの定義(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def tp_cost
|
||
tp_cost = Array.new
|
||
cheack_note = @note
|
||
cheack_note.match(/<消費TP\s?(\d+)([%])?>/)
|
||
return @tp_cost if $1 == nil
|
||
|
||
tp_cost[0] = 0
|
||
tp_cost[1] = 0
|
||
tp_cost[0] = $1.to_i if $1 != nil
|
||
tp_cost[1] = 1 if $2 != nil
|
||
return tp_cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 消費HPの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def hp_cost#紅茶走改造
|
||
hp_cost = Array.new
|
||
hp_cost[0] = 0 ; hp_cost[1] = 0
|
||
return hp_cost unless @note
|
||
@note.match(/<消費HP\s?(\d+)([%])?>/)
|
||
hp_cost[0] = $1.to_i if $1 ; hp_cost[1] = 1 if $2
|
||
return hp_cost if $1
|
||
|
||
@note.match(/<消費MAXHP\s?(\d+)%>/)
|
||
hp_cost[0] = $1.to_i if $1 ; hp_cost[1] = 2 if $1
|
||
return hp_cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費MPの定義(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def mp_cost
|
||
mp_cost = Array.new
|
||
cheack_note = @note
|
||
cheack_note.match(/<消費MP\s?(\d+)([%])?>/)
|
||
return @mp_cost if $1 == nil
|
||
|
||
mp_cost[0] = 0
|
||
mp_cost[1] = 0
|
||
mp_cost[0] = $1.to_i if $1 != nil
|
||
mp_cost[1] = 1 if $2 != nil
|
||
return mp_cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費GOLDの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gold_cost
|
||
cheack_note = @note
|
||
cheack_note.match(/<消費金額\s?(\d+)>/)
|
||
return 0 if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費アイテムの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def item_cost
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<消費アイテム\s?(\d+-\d+(?:\s?*,\s?*\d+-\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 自爆スキルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def life_cost
|
||
cheack_note = @note
|
||
return true if cheack_note.include?("<自爆スキル>")
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 必要アイテムの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_used_item
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<必要アイテム\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 必要武器タイプの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def required_add_wtype_id
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<必要武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 要求武器タイプの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_wtype_id_all
|
||
cheack_note = @note
|
||
#メモ欄から配列を作成
|
||
list = cheack_note.scan(/<要求武器タイプ\s?(\d+(?:\s?*,\s?*\d+)*)>/)
|
||
save_list = Array.new
|
||
unless list == [] and list.empty?
|
||
$1.scan(/\d+/).each { |num| save_list.push(num.to_i)}
|
||
end
|
||
return save_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 二刀流スキルの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def need_two_weapon
|
||
cheack_note = @note
|
||
return true if cheack_note.include?("<二刀流要求>")
|
||
return false
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ RPG::EquipItem(再定義)
|
||
#==============================================================================
|
||
class RPG::EquipItem < RPG::BaseItem
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備タイプの定義(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def etype_id
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備タイプ\s?(\d+)>/)
|
||
return @etype_id if $1 == nil
|
||
return $1.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備タイプの定義(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def etype_id=(etype_id)
|
||
@etype_id = etype_id
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ RPG::Enemy(追加定義)
|
||
#==============================================================================
|
||
class RPG::Enemy < RPG::BaseItem
|
||
#--------------------------------------------------------------------------
|
||
# ● 初期化(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias kure_jobLv_before_initialize initialize
|
||
def initialize
|
||
kure_jobLv_before_initialize
|
||
@jobexp = 0 #職業レベル
|
||
@equip_exp = 0 #装備個別管理
|
||
@ability_exp = 0 #AP制スキル習得
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 職業経験値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def jobexp
|
||
if @note != ""
|
||
cheack_note = @note
|
||
cheack_note.match(/<職業Exp\s?(\d+)>/)
|
||
if $1 == nil
|
||
return @exp
|
||
else
|
||
return jobexp = $1.to_i
|
||
end
|
||
else
|
||
return @exp
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備経験値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def equip_exp
|
||
if @note != ""
|
||
cheack_note = @note
|
||
cheack_note.match(/<装備Exp\s?(\d+)>/)
|
||
if $1 == nil
|
||
return @exp
|
||
else
|
||
return $1.to_i
|
||
end
|
||
else
|
||
return @exp
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アビリティポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def ability_exp
|
||
if @note != ""
|
||
cheack_note = @note
|
||
cheack_note.match(/<獲得AP\s?(\d+)>/)
|
||
if $1 == nil
|
||
return 0
|
||
else
|
||
return $1.to_i
|
||
end
|
||
else
|
||
return 0
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備経験値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def equip_exp=(equip_exp)
|
||
equip_exp = equip_exp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 職業経験値の定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def jobexp=(jobexp)
|
||
@jobexp = jobexp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アビリティポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def ability_exp=(ability_exp)
|
||
@ability_exp = ability_exp
|
||
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
|
||
|
||
cheack_note = @note
|
||
while cheack_note do
|
||
cheack_note.match(/<追加ドロップ\s?([IWA]),\s?(\d+),\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
|
||
cheack_note = $'
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 盗めるアイテムの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def steal_list
|
||
steal_list = Array.new
|
||
|
||
cheack_note = @note
|
||
while cheack_note do
|
||
cheack_note.match(/<スティールリスト\s?(\d+),\s?([IWA]),\s?(\d+),\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] = [] unless steal_list[$1.to_i]
|
||
steal_list[$1.to_i].push([kind, data_id, denominator])
|
||
end
|
||
cheack_note = $'
|
||
end
|
||
|
||
return steal_list
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Battler
|
||
#==============================================================================
|
||
class Game_Battler < Game_BattlerBase
|
||
#--------------------------------------------------------------------------
|
||
# ● 追加定数（使用効果）
|
||
#--------------------------------------------------------------------------
|
||
EFFECT_STEAL = 45 #盗むスキル
|
||
EFFECT_SKILL_RESET = 46 #スキルポイントリセット
|
||
#--------------------------------------------------------------------------
|
||
# ○ 使用効果の適用(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def item_effect_apply(user, item, effect)
|
||
method_table = {
|
||
EFFECT_RECOVER_HP => :item_effect_recover_hp,
|
||
EFFECT_RECOVER_MP => :item_effect_recover_mp,
|
||
EFFECT_GAIN_TP => :item_effect_gain_tp,
|
||
EFFECT_ADD_STATE => :item_effect_add_state,
|
||
EFFECT_REMOVE_STATE => :item_effect_remove_state,
|
||
EFFECT_ADD_BUFF => :item_effect_add_buff,
|
||
EFFECT_ADD_DEBUFF => :item_effect_add_debuff,
|
||
EFFECT_REMOVE_BUFF => :item_effect_remove_buff,
|
||
EFFECT_REMOVE_DEBUFF => :item_effect_remove_debuff,
|
||
EFFECT_SPECIAL => :item_effect_special,
|
||
EFFECT_GROW => :item_effect_grow,
|
||
EFFECT_LEARN_SKILL => :item_effect_learn_skill,
|
||
EFFECT_COMMON_EVENT => :item_effect_common_event,
|
||
EFFECT_STEAL => :item_effect_steal,
|
||
EFFECT_SKILL_RESET => :item_effect_reset_skillpoint,
|
||
}
|
||
method_name = method_table[effect.code]
|
||
send(method_name, user, item, effect) if method_name
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 使用効果［HP 回復］
|
||
#--------------------------------------------------------------------------
|
||
def item_effect_recover_hp(user, item, effect)
|
||
value = (mhp * effect.value1 + effect.value2) * rec
|
||
value *= user.pha if item.is_a?(RPG::Item)
|
||
value = value.to_i
|
||
|
||
if self.reverse_heel
|
||
@result.hp_damage += (value * self.reverse_heel).to_i
|
||
self.hp -= (value * self.reverse_heel).to_i
|
||
else
|
||
@result.hp_damage -= value
|
||
self.hp += value
|
||
end
|
||
@result.success = true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 使用効果［アイテムスティール］
|
||
#--------------------------------------------------------------------------
|
||
def item_effect_steal(user, item, effect)
|
||
if enemy?
|
||
@result.use_steal = true
|
||
if self.non_stealed?
|
||
steal_list = self.steal_list[effect.data_id]
|
||
#盗めるアイテムのリストがあれば処理
|
||
if steal_list != nil
|
||
for list in 0..steal_list.size - 1
|
||
if steal_list[list]
|
||
#成功判定
|
||
dice = steal_list[list][2]
|
||
dice = (dice / user.battler_add_ability(0)).to_i if user.actor?
|
||
|
||
if rand(dice) == 0 or dice == 0
|
||
case steal_list[list][0]
|
||
when 1
|
||
item = $data_items[steal_list[list][1]]
|
||
when 2
|
||
item = $data_weapons[steal_list[list][1]]
|
||
when 3
|
||
item = $data_armors[steal_list[list][1]]
|
||
end
|
||
$game_party.gain_item(item, 1)
|
||
self.steal = true
|
||
@result.steal = item
|
||
end
|
||
end
|
||
end
|
||
else
|
||
@result.stealed = true
|
||
end
|
||
else
|
||
@result.stealed = true
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 使用効果［スキルポイントリセット］
|
||
#--------------------------------------------------------------------------
|
||
def item_effect_reset_skillpoint(user, item, effect)
|
||
if actor?
|
||
self.reset_skill_flag = true
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● オートリザレクション判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def auto_revive
|
||
return 1 if battler_add_ability(1) > 1
|
||
return battler_add_ability(1) if battler_add_ability(1) != 0
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 踏みとどまりの判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def auto_stand
|
||
return false if battler_add_ability(2) == 0
|
||
return true if battler_add_ability(2) > 1
|
||
return true if self.hp > mhp * battler_add_ability(2)
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 回復反転の判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def reverse_heel
|
||
return false if battler_add_ability(3) == 0
|
||
return battler_add_ability(3)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキル使用コストの支払い可能判定(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_cost_payable?(skill)
|
||
return false if tp < skill_tp_cost(skill)
|
||
return false if mp < skill_mp_cost(skill)
|
||
return false if hp < skill_hp_cost(skill)
|
||
|
||
if actor?
|
||
return false if $game_party.gold < skill_gold_cost(skill)
|
||
|
||
need_list = skill_need_item(skill)
|
||
for n_list in 0..need_list.size - 1
|
||
id = need_list[n_list]
|
||
return false unless $game_party.has_item?($data_items[id])
|
||
end
|
||
|
||
item_cost = skill_item_cost(skill)
|
||
for i_list in 0..item_cost.size - 1
|
||
if item_cost[i_list]
|
||
id = item_cost[i_list][0]
|
||
num = item_cost[i_list][1]
|
||
return false if $game_party.item_number($data_items[id]) < num
|
||
end
|
||
end
|
||
end
|
||
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキル使用コストの支払い(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def pay_skill_cost(skill)
|
||
self.mp -= skill_mp_cost(skill)
|
||
self.tp -= skill_tp_cost(skill)
|
||
self.hp = [self.hp - skill_hp_cost(skill),1].max
|
||
if actor?
|
||
$game_party.lose_gold(skill_gold_cost(skill))
|
||
|
||
item_cost = skill_item_cost(skill)
|
||
for list in 0..item_cost.size - 1
|
||
if item_cost[list]
|
||
id = item_cost[list][0]
|
||
num = item_cost[list][1] * -1
|
||
$game_party.gain_item($data_items[id], num)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの消費 HP 計算(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_hp_cost(skill)
|
||
cost = skill.hp_cost
|
||
return cost[0] if cost[1] == 0
|
||
return (mhp * cost[0] / 100).to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの消費 MP 計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
#def skill_mp_cost(skill)紅茶走コメントアウト
|
||
#cost = skill.mp_cost
|
||
#if cost.instance_of?(Array)
|
||
# return (cost[0] * mcr).to_i if cost[1] == 0
|
||
# return (mmp * cost[0] / 100 * mcr).to_i
|
||
#end
|
||
# return cost
|
||
# end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの消費 TP 計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_tp_cost(skill)
|
||
cost = skill.tp_cost
|
||
if cost.instance_of?(Array)
|
||
return cost[0] if cost[1] == 0
|
||
return (max_tp * cost[0] / 100).to_i
|
||
end
|
||
return cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 自爆スキル(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def pay_life(item)
|
||
if item.is_a?(RPG::Skill)
|
||
if item.life_cost
|
||
self.hp = 0
|
||
perform_collapse_effect
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ オートリザレクション(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def revive_life(rper)
|
||
return if self.hp != 0
|
||
self.hp = (mhp * rper).to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル／アイテムの属性修正値を取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def item_element_rate(user, item)
|
||
#複数属性のリストを習得
|
||
e_list = item.attack_elements_list
|
||
|
||
#アクターであれば反映属性を取得
|
||
e_list += user.reflect_elements if user.actor?
|
||
|
||
if e_list == ([] or empty?)
|
||
e_id = item.damage.element_id
|
||
if e_id < 0
|
||
result = user.atk_elements.empty? ? 1.0 : elements_max_rate(user, user.atk_elements)
|
||
else
|
||
result = element_rate(e_id) * elements_booster_rate(user, e_id)
|
||
result -= elements_drain_rate(e_id)
|
||
end
|
||
else
|
||
e_list.push(item.damage.element_id)
|
||
result = elements_max_rate(user, e_list)
|
||
end
|
||
|
||
#アクターであればダメージ増加補正を取得
|
||
result *= gain_damage_rate(user, item) if user.actor?
|
||
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 属性の最大修正値の取得(再定義)
|
||
# elements : 属性 ID の配列
|
||
# 与えられた属性の中で最も有効な修正値を返す
|
||
#--------------------------------------------------------------------------
|
||
def elements_max_rate(user, elements)
|
||
elements.inject([0.0]) {|r, i| r.push((element_rate(i) * elements_booster_rate(user, i)) - elements_drain_rate(i)) }.max
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 属性ブースターの取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def elements_booster_rate(user, element_id)
|
||
#属性ブースターの配列取得
|
||
booster = user.multi_boost(0)
|
||
result = 1
|
||
result = (100 + booster[element_id]).to_f / 100 if booster[element_id]
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 属性吸収の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def elements_drain_rate(element_id)
|
||
#属性吸収の配列取得
|
||
drain = multi_boost(1)
|
||
result = 0
|
||
result = drain[element_id].to_f / 100 if drain[element_id]
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ増加補正の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_damage_rate(user, item)
|
||
gain_rate = 1
|
||
|
||
#仲間思い補正
|
||
companion_boost = 1 + $game_party.dead_members.size * (item.companion_revise.to_f / 100)
|
||
gain_rate *= companion_boost
|
||
|
||
#装備補正
|
||
weapon_id_list = user.weapons.collect{|obj| obj.wtype_id}
|
||
wd_rate_list = item.weapon_d_rate
|
||
equip_booster = 0
|
||
if weapon_id_list != []
|
||
for list in 0..weapon_id_list.size - 1
|
||
#装備ブースター
|
||
boost_id = weapon_id_list[list]
|
||
if item.physical?
|
||
equip_booster += user.multi_boost(2)[boost_id] if user.multi_boost(2)[boost_id]
|
||
elsif item.magical?
|
||
equip_booster += user.multi_boost(3)[boost_id] if user.multi_boost(3)[boost_id]
|
||
else
|
||
equip_booster += user.multi_boost(4)[boost_id] if user.multi_boost(4)[boost_id]
|
||
end
|
||
|
||
#スキル倍率補正
|
||
equip_booster += wd_rate_list[boost_id] if wd_rate_list[boost_id]
|
||
|
||
end
|
||
end
|
||
gain_rate *= 1 + (equip_booster.to_f / 100)
|
||
|
||
return gain_rate
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ブースター配列を取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def multi_boost(boost_id)
|
||
booster = Array.new
|
||
sub = Array.new
|
||
|
||
#ブースター配列を作成
|
||
if actor?
|
||
actor = $data_actors[@actor_id].multi_booster[boost_id]
|
||
sub = $data_classes[@sub_class_id].multi_booster[boost_id] if @sub_class_id != 0
|
||
job = $data_classes[@class_id].multi_booster[boost_id]
|
||
weapon = @equips.select{|obj| obj != nil && obj.is_weapon?}.collect{|obj| $data_weapons[obj.id].multi_booster[boost_id]}
|
||
armor = @equips.select{|obj| obj != nil && obj.is_armor?}.collect{|obj| $data_armors[obj.id].multi_booster[boost_id]}
|
||
passive = passive_skills.collect{|obj| obj.multi_booster[boost_id]}
|
||
sta = states.collect{|obj| obj.multi_booster[boost_id]}
|
||
booster += actor + sub + job + weapon + armor + passive + sta
|
||
end
|
||
if enemy?
|
||
enemy_e = $data_enemies[@enemy_id].multi_booster[boost_id]
|
||
sta_e = states.collect{|obj| obj.multi_booster[boost_id]}
|
||
booster += enemy_e + sta_e
|
||
end
|
||
booster.compact!
|
||
booster.flatten!
|
||
|
||
result = Array.new
|
||
if booster != []
|
||
for list in 0..booster.size - 1
|
||
if list % 2 == 0
|
||
if booster[list] && booster[list + 1]
|
||
result[booster[list]] = 0 unless result[booster[list]]
|
||
result[booster[list]] += booster[list + 1]
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトラーー追加能力判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def battler_add_ability(add_ability_id)
|
||
all_list = Array.new
|
||
case add_ability_id
|
||
when 0
|
||
sub = 100
|
||
when 1,2,3
|
||
sub = 0
|
||
end
|
||
|
||
if actor?
|
||
actor = [$data_actors[@actor_id].battler_add_ability[add_ability_id]]
|
||
sub = [$data_classes[@sub_class_id].battler_add_ability[add_ability_id]] if @sub_class_id != 0
|
||
job = [$data_classes[@class_id].battler_add_ability[add_ability_id],sub]
|
||
weapon = @equips.select{|obj| obj != nil && obj.is_weapon?}.collect{|obj| $data_weapons[obj.id].battler_add_ability[add_ability_id]}
|
||
armor = @equips.select{|obj| obj != nil && obj.is_armor?}.collect{|obj| $data_armors[obj.id].battler_add_ability[add_ability_id]}
|
||
passive = passive_skills.collect{|obj| obj.battler_add_ability[add_ability_id]}
|
||
sta = states.collect{|obj| obj.battler_add_ability[add_ability_id]}
|
||
all_list += actor + job + weapon + armor + passive + sta
|
||
end
|
||
|
||
if enemy?
|
||
enemy_e = [$data_enemies[@enemy_id].battler_add_ability[add_ability_id]]
|
||
sta_e = states.collect{|obj| obj.battler_add_ability[add_ability_id]}
|
||
all_list += enemy_e + sta_e
|
||
end
|
||
all_list.flatten!
|
||
|
||
case add_ability_id
|
||
when 0,1,3
|
||
value = all_list.max.to_f / 100
|
||
when 2
|
||
all_list.delete(0)
|
||
if all_list != []
|
||
value = all_list.min.to_f / 100
|
||
else
|
||
value = 0
|
||
end
|
||
end
|
||
return value
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def make_damage_value(user, item)
|
||
value = item.damage.eval(user, self, $game_variables)
|
||
value *= item_element_rate(user, item)
|
||
value *= pdr if item.physical?
|
||
value *= mdr if item.magical?
|
||
value *= rec if item.damage.recover?
|
||
value = apply_critical(value) if @result.critical
|
||
value = apply_variance(value, item.damage.variance)
|
||
value = apply_guard(value)
|
||
|
||
value = apply_stand(value)
|
||
@result.make_damage(value.to_i, item)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 踏みとどまりの適用
|
||
#--------------------------------------------------------------------------
|
||
def apply_stand(damage)
|
||
return damage unless self.auto_stand
|
||
return if damage < self.hp
|
||
|
||
@result.auto_stand = true
|
||
states.each do |state|
|
||
if state.battler_add_ability[2] != 0
|
||
remove_state(state.id)
|
||
end
|
||
end
|
||
|
||
return [damage, self.hp - 1].min
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Actor(再定義項目集積)
|
||
#==============================================================================
|
||
class Game_Actor < Game_Battler
|
||
attr_reader :joblevel # 職業レベル
|
||
attr_reader :sub_class_level # サブクラスレベル
|
||
attr_reader :sub_class_id # サブクラス ID
|
||
#--------------------------------------------------------------------------
|
||
# ■★▲ セットアップ(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def setup(actor_id)
|
||
@used_skill_point = 0 #スキルポイントシステム
|
||
@joblevel = 1 #職業レベル
|
||
@jobexp = {} #職業レベル
|
||
@sub_class_id = 0 #サブクラス
|
||
@sub_class_level = 1 #サブクラス
|
||
@ability_point = [] #アビリティポイント保存配列
|
||
@actor_id = actor_id
|
||
@name = actor.name
|
||
@nickname = actor.nickname
|
||
init_graphics
|
||
@class_id = actor.class_id
|
||
@level = actor.initial_level
|
||
@exp = {}
|
||
clear_master_object
|
||
@equips = []
|
||
init_exp
|
||
init_jobexp if KURE::BaseScript::USE_JOBLv == 1 #職業レベル
|
||
init_actor_exp
|
||
init_sub_class_exp if KURE::BaseScript::USE_JOBLv == 1 #職業レベル
|
||
init_skills
|
||
init_equips(actor.equips)
|
||
clear_param_plus
|
||
recover_all
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● マスターオブジェクトの初期化(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def clear_master_object
|
||
return unless @equips
|
||
return if KURE::BaseScript::USE_SortOut == 0
|
||
equip_list = equips
|
||
master_w_list = $game_party.master_weapons_list
|
||
master_a_list = $game_party.master_armors_list
|
||
|
||
return unless master_w_list
|
||
return unless master_a_list
|
||
|
||
for slot in 0..equip_list.size - 1
|
||
if equip_list[slot]
|
||
if equip_list[slot].class == RPG::Weapon
|
||
master_w_list[equip_list[slot].identify_id] = nil
|
||
end
|
||
if equip_list[slot].class == RPG::Armor
|
||
master_a_list[equip_list[slot].identify_id] = nil
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 経験値の初期化(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def init_exp
|
||
@classlevel_list = []
|
||
@exp[@class_id] = current_level_exp
|
||
@classlevel_list[@class_id] = @level if KURE::BaseScript::USE_JOBLv == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 職業経験値の初期化(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def init_jobexp
|
||
@classlevel_list = []
|
||
@classlevel_list[@class_id] = @joblevel
|
||
@jobexp[@class_id] = current_joblevel_exp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ●▲ アクター経験済み職業初期設定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def init_actor_exp
|
||
exp_list = $data_actors[@actor_id].exp_jobchange_class
|
||
for i in 0..exp_list.size - 1
|
||
if i % 2 == 0
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
@jobexp[exp_list[i]] = jobexp_for_level(exp_list[i+1])
|
||
else
|
||
@exp[exp_list[i]] = exp_for_level(exp_list[i+1])
|
||
end
|
||
@classlevel_list[exp_list[i]] = exp_list[i+1]
|
||
end
|
||
end
|
||
@level = @classlevel_list[@class_id] if KURE::BaseScript::USE_JOBLv == 0
|
||
@joblevel = @classlevel_list[@class_id] if KURE::BaseScript::USE_JOBLv == 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ サブクラス経験値の初期化(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def init_sub_class_exp
|
||
@sub_class_id = actor.first_sub_class
|
||
@sub_class_level = @classlevel_list[@sub_class_id] if @classlevel_list[@sub_class_id]
|
||
if @sub_class_id != 0
|
||
@classlevel_list[@sub_class_id] = @sub_class_level
|
||
@jobexp[@sub_class_id] = current_sub_class_level_exp
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ サブクラスオブジェクト取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def sub_class
|
||
$data_classes[@sub_class_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 現在の職業レベルの最低経験値を取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def current_joblevel_exp
|
||
jobexp_for_level(@joblevel)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 現在のサブクラスレベルの最低経験値を取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def current_sub_class_level_exp
|
||
sub_class_exp_for_level(@sub_class_level)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 指定職業レベルに上がるのに必要な累計経験値の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def jobexp_for_level(level)
|
||
self.class.exp_for_level(level)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 指定サブクラスレベルに上がるのに必要な累計経験値の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def sub_class_exp_for_level(level)
|
||
$data_classes[@sub_class_id].exp_for_level(level)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ クラスごとのレベルリストの呼び出し(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def class_level_list
|
||
@sub_class_id = 0 if @sub_class_id == nil
|
||
@classlevel_list = [] if @classlevel_list == nil
|
||
add_level = @level
|
||
add_level = @joblevel if KURE::BaseScript::USE_JOBLv == 1
|
||
@classlevel_list[@class_id] = add_level
|
||
if @sub_class_id != 0
|
||
add_level = @sub_class_level if KURE::BaseScript::USE_JOBLv == 1
|
||
@classlevel_list[@sub_class_id] = add_level if KURE::BaseScript::USE_JOBLv == 1
|
||
end
|
||
return @classlevel_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★▲ スキルの初期化(項目集積再定義)
|
||
#--------------------------------------------------------------------------
|
||
def init_skills
|
||
@skills = []
|
||
@sub_class_skills = [] #サブクラススキル
|
||
@memory_skills = [] #スキルメモライズシステム
|
||
@extra_skills = [] #スキルメモライズシステム
|
||
@passive_skills = [] #パッシブスキル
|
||
|
||
#スキルポイントシステム利用時には消費ポイントを初期化
|
||
@used_skill_point = [] if KURE::BaseScript::USE_Skill_Point == 1
|
||
@save_class_skills = []
|
||
|
||
#職業レベルの併用化チェックにより初期スキル習得処理を分岐
|
||
cheack_first_Lv = @level
|
||
cheack_first_Lv = @joblevel if KURE::BaseScript::USE_JOBLv == 1
|
||
|
||
#初期Lvで覚えるスキルを処理
|
||
self.class.learnings.each do |learning|
|
||
#スキルポイントシステムを利用している場合、初期スキルを制限する
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill(learning.skill_id) if learning.level <= cheack_first_Lv
|
||
end
|
||
else
|
||
learn_skill(learning.skill_id) if learning.level <= cheack_first_Lv
|
||
end
|
||
end
|
||
|
||
#サブクラス設定時は初期Lvで覚えるスキルを処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if @sub_class_id != 0
|
||
$data_classes[@sub_class_id].learnings.each do |learning|
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill_sub(learning.skill_id) if learning.level <= @sub_class_level
|
||
end
|
||
else
|
||
learn_skill_sub(learning.skill_id) if learning.level <= @sub_class_level
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#職業レベルを導入している場合、Lv1固有スキルを処理する
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if $data_actors[@actor_id].actor_peculiar_skill != []
|
||
for i in 0..$data_actors[@actor_id].actor_peculiar_skill.size - 1
|
||
if i % 2 == 0
|
||
if @level >= $data_actors[@actor_id].actor_peculiar_skill[i]
|
||
learn_skill($data_actors[@actor_id].actor_peculiar_skill[i + 1])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#初期登録スキルが有れば処理する
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
@memory_skills = [] if $data_actors[@actor_id].first_memorize.size != 0
|
||
for i in 0..$data_actors[@actor_id].first_memorize.size - 1
|
||
if $data_skills[$data_actors[@actor_id].first_memorize[i]]
|
||
unless skill_memorize?($data_skills[$data_actors[@actor_id].first_memorize[i]])
|
||
@memory_skills.push($data_actors[@actor_id].first_memorize[i])
|
||
end
|
||
end
|
||
end
|
||
chain_memorize_set
|
||
end
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルを覚える(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def learn_skill(skill_id)
|
||
unless skill_learn?($data_skills[skill_id])
|
||
@skills.push(skill_id)
|
||
@skills.sort!
|
||
end
|
||
|
||
#メモライズ容量と相談して登録する
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
unless KURE::SkillMemorize::NOT_AUTO_MEMORIZE.include?($data_skills[skill_id].stype_id)
|
||
if $data_skills[skill_id].not_auto_memorize == false
|
||
add_memorize_skill_ir(skill_id, true) if KURE::SkillMemorize::AUTO_MEMORIZE == 1
|
||
end
|
||
end
|
||
end
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルを忘れる(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def forget_skill(skill_id)
|
||
@skills.delete(skill_id)
|
||
|
||
#メモライズ使用時は削除する
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
@memory_skills.delete(skill_id)
|
||
end
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ スキルオブジェクトの配列取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def skills
|
||
@sub_class_skills = [] if @sub_class_skills == nil
|
||
#スキルメモライズ時のスキルオブジェクト
|
||
if KURE::BaseScript::USE_Skill_Memorize == 1
|
||
(@skills | @sub_class_skills | added_skills | @extra_skills).sort.collect {|id| $data_skills[id] }
|
||
#通常のスキルオブジェクト
|
||
else
|
||
(@skills | @sub_class_skills | added_skills).sort.collect {|id| $data_skills[id] }
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 習得スキルオブジェクトの配列取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def learned_skill_list
|
||
@sub_class_skills = [] if @sub_class_skills == nil
|
||
return (@skills | @sub_class_skills ).sort.collect {|id| $data_skills[id] }
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ 現在使用可能かどうかを判定する
|
||
#--------------------------------------------------------------------------
|
||
def usable_now?(skill)
|
||
return true if KURE::BaseScript::USE_Skill_Memorize == 0
|
||
return true if @memory_skills.include?(skill.id) or @extra_skills.include?(skill.id) or unselect_skill?(skill.id)
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 登録不要のスキル判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def unselect_skill?(skill_id)
|
||
return unless skill_id != nil or skill_id == 0
|
||
skilldata = $data_skills[skill_id].note
|
||
if skilldata.include?("<メモライズ不要>")
|
||
return true
|
||
else
|
||
skilldata.each_line { |line|
|
||
memo = line.scan(/<メモライズ不要\s?(\d+)>/)
|
||
memo = memo.flatten
|
||
if memo != nil and not memo.empty?
|
||
return true if memo[0].to_i == id
|
||
end
|
||
}
|
||
return false
|
||
end
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ パッシブスキルオブジェクトの配列のセット
|
||
#--------------------------------------------------------------------------
|
||
def set_passive_skills
|
||
@passive_skills = []
|
||
for i in 0..skills.size - 1
|
||
if usable_now?(skills[i]) == true
|
||
object = skills[i]
|
||
#武器のオブジェクトを出力
|
||
if object.passive_skill_id_w.size != 0
|
||
for weapon in 0..object.passive_skill_id_w.size - 1
|
||
@passive_skills.push($data_weapons[object.passive_skill_id_w[weapon]])
|
||
end
|
||
end
|
||
#防具のオブジェクトを出力
|
||
if object.passive_skill_id_a != []
|
||
for armor in 0..object.passive_skill_id_a.size - 1
|
||
@passive_skills.push($data_armors[object.passive_skill_id_a[armor]])
|
||
end
|
||
end
|
||
#職業のオブジェクトを出力
|
||
if object.passive_skill_id_c != []
|
||
for job in 0..object.passive_skill_id_c.size - 1
|
||
@passive_skills.push($data_classes[object.passive_skill_id_c[job]])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
for j in 0..states.size - 1
|
||
object = states[j]
|
||
#武器のオブジェクトを出力
|
||
if object.passive_skill_id_w.size != 0
|
||
for weapon in 0..object.passive_skill_id_w.size - 1
|
||
@passive_skills.push($data_weapons[object.passive_skill_id_w[weapon]])
|
||
end
|
||
end
|
||
#防具のオブジェクトを出力
|
||
if object.passive_skill_id_a != []
|
||
for armor in 0..object.passive_skill_id_a.size - 1
|
||
@passive_skills.push($data_armors[object.passive_skill_id_a[armor]])
|
||
end
|
||
end
|
||
#職業のオブジェクトを出力
|
||
if object.passive_skill_id_c != []
|
||
for job in 0..object.passive_skill_id_c.size - 1
|
||
@passive_skills.push($data_classes[object.passive_skill_id_c[job]])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■★ パッシブスキルオブジェクトの配列のセット
|
||
#--------------------------------------------------------------------------
|
||
def passive_skills
|
||
@passive_skills = [] unless @passive_skills
|
||
@passive_skills
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アビリティポイントの配列のセット
|
||
#--------------------------------------------------------------------------
|
||
def ability_point
|
||
@ability_point = [] unless @ability_point
|
||
@ability_point
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 特徴を保持する全オブジェクトの配列取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def feature_objects
|
||
super + [actor] + [self.class] + equips.compact + passive_skills.compact
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 全ての特徴オブジェクトの配列取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def all_features
|
||
sub_class_features = []
|
||
base_features = feature_objects.inject([]) {|r, obj| r + obj.features }
|
||
|
||
#サブクラスの設定により取得配列を変更
|
||
if @sub_class_id != 0 and KURE::JobLvSystem::SUB_CLASS_FEATURE == 1
|
||
sub_class_features = $data_classes[@sub_class_id].features
|
||
|
||
#適用外特徴を除外する。
|
||
apply = $data_classes[@sub_class_id].not_applied_features
|
||
for code in 0..apply.size - 1
|
||
sub_class_features = sub_class_features.select {|ft| ft.code != apply[code]}
|
||
end
|
||
|
||
#適用外特徴データを除外する
|
||
apply_data = $data_classes[@sub_class_id].not_applied_features_data
|
||
for code in 0..apply_data.size - 1
|
||
if code % 2 == 0
|
||
if apply_data[code] && apply_data[code + 1]
|
||
sub_class_features = sub_class_features.select {|ft| ft.code != apply_data[code] or ft.data_id != apply_data[code + 1]}
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
return base_features + sub_class_features
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 特徴オブジェクトの配列取得（特徴コードを限定）
|
||
#--------------------------------------------------------------------------
|
||
def features(code)
|
||
all_features.select {|ft| ft.code == code }
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲☆ 通常能力値の基本値取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def param_base(param_id)
|
||
#基本能力値の取得
|
||
base_class = $data_actors[@actor_id].base_param_index
|
||
if base_class == 0
|
||
class_base = self.class.params[param_id, @level]
|
||
else
|
||
class_base = $data_classes[base_class].params[param_id, @level]
|
||
end
|
||
|
||
sub_class_base = 0
|
||
#サブクラス関連のステータス処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
sub_class_base = self.sub_class.params[param_id, @level] if @sub_class_id != 0
|
||
sub_class_base = sub_class_base * KURE::JobLvSystem::SUB_CLASS_STATUS_RATE
|
||
class_base = class_base * KURE::JobLvSystem::MAIN_CLASS_STATUS_RATE if @sub_class_id != 0
|
||
end
|
||
|
||
passive_base = 0
|
||
#パッシブスキル関連のステータス処理
|
||
for i in 0..passive_skills.size - 1
|
||
passive_base += passive_skills[i].params[param_id] if passive_skills[i].kind_of?(RPG::EquipItem)
|
||
end
|
||
|
||
return class_base + sub_class_base + passive_base
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ■ 装備の変更(エイリアス定義)
|
||
#--------------------------------------------------------------------------
|
||
alias k_skillmemorize_before_change_equip change_equip
|
||
def change_equip(slot_id, item)
|
||
k_skillmemorize_before_change_equip(slot_id, item)
|
||
#追加装備のスキル削除処理
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲★ レベルアップ(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def level_up
|
||
@level += 1
|
||
Audio.se_play("Audio/SE/salaya_levelup", $game_system.m_v[3], 100)#紅茶走
|
||
#職業レベルを導入している場合、固有スキルを処理する
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if $data_actors[@actor_id].actor_peculiar_skill != []
|
||
for i in 0..$data_actors[@actor_id].actor_peculiar_skill.size - 1
|
||
if i % 2 == 0
|
||
if @level == $data_actors[@actor_id].actor_peculiar_skill[i]
|
||
learn_skill($data_actors[@actor_id].actor_peculiar_skill[i + 1])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#職業レベルを導入しない場合、スキルポイントシステムを確認する
|
||
else
|
||
#スキルポイントシステムを利用している場合、初期スキルを制限する
|
||
self.class.learnings.each do |learning|
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill(learning.skill_id) if learning.level == @level
|
||
end
|
||
else
|
||
learn_skill(learning.skill_id) if learning.level == @level
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲★ 職業レベルアップ(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def joblevel_up
|
||
@joblevel += 1
|
||
#スキルポイントシステムを利用している場合、初期スキルを制限する
|
||
self.class.learnings.each do |learning|
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill(learning.skill_id) if learning.level == @joblevel
|
||
end
|
||
else
|
||
learn_skill(learning.skill_id) if learning.level == @joblevel
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲★ サブクラスレベルアップ(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def sub_class_level_up
|
||
#サブクラス設定時
|
||
if @sub_class_id != 0
|
||
@sub_class_level += 1
|
||
$data_classes[@sub_class_id].learnings.each do |learning|
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill_sub(learning.skill_id) if learning.level == @sub_class_level
|
||
end
|
||
else
|
||
learn_skill_sub(learning.skill_id) if learning.level == @sub_class_level
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 職業レベルダウン(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def joblevel_down
|
||
@joblevel -= 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ サブクラスレベルダウン(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def sub_class_level_down
|
||
@sub_class_level -= 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 職業経験値の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def jobexp
|
||
return 0 if @jobexp[@class_id] == nil
|
||
return @jobexp[@class_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ サブクラス経験値の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def sub_class_exp
|
||
return 0 if @jobexp[@sub_class_id] == nil
|
||
return @jobexp[@sub_class_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 経験値の獲得（経験獲得率を考慮）(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def gain_exp(exp, jobexp = nil, equip_exp = nil, a_exp = nil)
|
||
jobexp = 0 if jobexp == nil
|
||
equip_exp = 0 if equip_exp == nil
|
||
a_exp = 0 if a_exp == nil
|
||
@sub_class_id = 0 if @sub_class_id == nil
|
||
|
||
#獲得した経験値を代入
|
||
base = self.exp + (exp * final_exp_rate).to_i
|
||
job = 0
|
||
sub = 0
|
||
equip = 0
|
||
|
||
#職業レベルを導入している場合、職業経験値を獲得させる
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
job = self.jobexp + (jobexp * final_exp_rate).to_i
|
||
sub = self.sub_class_exp + (jobexp * final_exp_rate * KURE::JobLvSystem::SUB_CLASS_EXP_RATE).to_i if @sub_class_id != 0
|
||
end
|
||
|
||
#装備個別管理を導入している場合装備経験値を獲得させる
|
||
if KURE::BaseScript::USE_SortOut == 1
|
||
equip = (equip_exp * final_exp_rate).to_i
|
||
end
|
||
change_exp(base, true, job, sub, equip, a_exp)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 経験値の変更(再定義)
|
||
# show : レベルアップ表示フラグ
|
||
#--------------------------------------------------------------------------
|
||
def change_exp(exp, show, jobexp = nil, subexp = nil, equip_exp = nil, a_exp = nil)
|
||
equip_exp = 0 if equip_exp == nil
|
||
jobexp = self.jobexp if jobexp == nil
|
||
a_exp = 0 if a_exp == nil
|
||
subexp = self.sub_class_exp if subexp == nil
|
||
|
||
#経験値増加
|
||
@exp[@class_id] = [exp, 0].max
|
||
last_level = @level
|
||
|
||
#職業経験値増加処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
@jobexp[@class_id] = [jobexp, 0].max
|
||
last_joblevel = @joblevel
|
||
if @sub_class_id != 0
|
||
@jobexp[@sub_class_id] = [subexp, 0].max
|
||
last_sublevel = @sub_class_level
|
||
end
|
||
end
|
||
|
||
#装備固有の経験値処理
|
||
if KURE::BaseScript::USE_SortOut == 1
|
||
for slot in 0..equips.size - 1
|
||
if equips[slot]
|
||
identify_id = equips[slot].identify_id
|
||
master_container = $game_party.item_master_container(equips[slot].class)
|
||
master_container[identify_id].equip_exp = equip_exp
|
||
end
|
||
end
|
||
end
|
||
|
||
last_skills = learned_skill_list
|
||
|
||
#APの処理
|
||
gain_ability_point(a_exp)
|
||
|
||
#レベルアップ処理
|
||
level_up while !max_level? && self.exp >= next_level_exp
|
||
level_down while self.exp < current_level_exp
|
||
|
||
#職業レベルのレベルアップ処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
joblevel_up while !max_joblevel? && self.jobexp >= next_joblevel_exp
|
||
joblevel_down while self.jobexp < current_joblevel_exp
|
||
if @sub_class_id != 0
|
||
sub_class_level_up while !max_sub_class_level? && self.sub_class_exp >= next_sub_class_level_exp
|
||
sub_class_level_down while self.sub_class_exp < current_sub_class_level_exp
|
||
end
|
||
end
|
||
|
||
up_base = @level - last_level
|
||
up_job = 0
|
||
up_sub = 0
|
||
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
up_job = @joblevel - last_joblevel
|
||
up_sub = @sub_class_level - last_sublevel if @sub_class_id != 0
|
||
end
|
||
|
||
new_skills = learned_skill_list
|
||
|
||
if up_base > 0 or up_job > 0 or up_sub > 0 or new_skills - last_skills != []
|
||
display_level_up(new_skills - last_skills, up_base, up_job, up_sub) if show
|
||
end
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ レベルアップメッセージの表示(再定義)
|
||
# new_skills : 新しく習得したスキルの配列
|
||
#--------------------------------------------------------------------------
|
||
def display_level_up(new_skills, base = 0, job = 0, sub = 0)
|
||
$game_message.new_page
|
||
$game_temp.reserve_common_event(19) #紅茶走
|
||
$game_message.add(sprintf(Vocab::LevelUp, @name, Vocab::level, @level)) if base > 0
|
||
if job > 0
|
||
if max_joblevel?
|
||
$game_message.add(@name + "は" + self.class.name + "の職業をマスターした。")
|
||
else
|
||
$game_message.add(sprintf(Vocab::LevelUp, @name, self.class.name + "の職業レベルが", @joblevel))
|
||
end
|
||
end
|
||
if sub > 0
|
||
if max_sub_class_level?
|
||
$game_message.add(@name + "は" + self.sub_class.name + "の職業をマスターした。")
|
||
else
|
||
$game_message.add(sprintf(Vocab::LevelUp, @name, self.sub_class.name + "の職業レベルが", @sub_class_level))
|
||
end
|
||
end
|
||
new_skills.each do |skill|
|
||
$game_message.add(sprintf(Vocab::ObtainSkill, skill.name))
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 最終的な経験獲得率の計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def final_exp_rate
|
||
exr * (battle_member? ? 1 : reserve_members_exp_rate)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アビリティポイントの配列のセット
|
||
#--------------------------------------------------------------------------
|
||
def gain_ability_point(a_exp)
|
||
return if a_exp == 0
|
||
@ability_point = [] unless @ability_point
|
||
get_list = Array.new
|
||
|
||
weapon = @equips.select{|obj| obj != nil && obj.is_weapon?}.collect{|obj| $data_weapons[obj.id].get_ability_point}
|
||
armor = @equips.select{|obj| obj != nil && obj.is_armor?}.collect{|obj| $data_armors[obj.id].get_ability_point}
|
||
|
||
get_list += weapon + armor
|
||
get_list.flatten!
|
||
get_list.compact!
|
||
|
||
return if get_list == ([] or empty?)
|
||
for ap in 0..get_list.size - 1
|
||
if ap % 2 == 0 && get_list[ap + 1]
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
#アビリティポイントを獲得
|
||
unless skill_learn?($data_skills[get_list[ap]]) or skill_learn_sub?($data_skills[get_list[ap]])
|
||
point = a_exp * get_list[ap + 1]
|
||
|
||
@ability_point[get_list[ap]] += point if @ability_point[get_list[ap]]
|
||
@ability_point[get_list[ap]] = point unless @ability_point[get_list[ap]]
|
||
|
||
#スキル習得判定
|
||
if @ability_point[get_list[ap]] >= $data_skills[get_list[ap]].need_ability_point
|
||
learn_skill(get_list[ap])
|
||
learn_skill_sub(get_list[ap])
|
||
@ability_point[get_list[ap]] = 0
|
||
end
|
||
end
|
||
else
|
||
#アビリティポイントを獲得
|
||
unless skill_learn?($data_skills[get_list[ap]])
|
||
point = a_exp * get_list[ap + 1]
|
||
|
||
@ability_point[get_list[ap]] += point if @ability_point[get_list[ap]]
|
||
@ability_point[get_list[ap]] = point unless @ability_point[get_list[ap]]
|
||
|
||
#スキル習得判定
|
||
if @ability_point[get_list[ap]] >= $data_skills[get_list[ap]].need_ability_point
|
||
learn_skill(get_list[ap])
|
||
@ability_point[get_list[ap]] = 0
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲★◆ 職業の変更(再定義)
|
||
# keep_exp : 経験値を引き継ぐ
|
||
#--------------------------------------------------------------------------
|
||
def change_class(class_id, keep_exp = true)
|
||
#転職前に習得スキルを保存する
|
||
@save_class_skills[@class_id] = [] if @save_class_skills[@class_id] == nil
|
||
@save_class_skills[@class_id] = @skills
|
||
|
||
@exp[class_id] = exp if keep_exp
|
||
@class_id = class_id
|
||
|
||
change_exp(@exp[@class_id] || 0, false, self.jobexp, self.sub_class_exp)
|
||
|
||
#転職後のスキルリストを確認する
|
||
@save_class_skills[@class_id] = [] if @save_class_skills[@class_id] == nil
|
||
|
||
#スキル削除モード時の処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if KURE::JobChange::DELETE_SKILL_MODE == 1
|
||
common_list = Array.new
|
||
for i in 0..@skills.size - 1
|
||
if $data_skills[@skills[i]].note.include?("<共有スキル>")
|
||
common_list.push(@skills[i])
|
||
end
|
||
end
|
||
|
||
@skills = @save_class_skills[@class_id]
|
||
@memory_skills = [] #スキルメモライズシステム
|
||
@extra_skills = [] #スキルメモライズシステム
|
||
|
||
for j in 0..common_list.size - 1
|
||
learn_skill(common_list[j]) if KURE::BaseScript::USE_Skill_Point == 0
|
||
end
|
||
end
|
||
end
|
||
|
||
#職業レベルを併用している場合は職業レベルを設定
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
change_exp(self.exp, false, @jobexp[@class_id] || 0,self.sub_class_exp)
|
||
end
|
||
|
||
#職業レベルの併用化チェックにより初期スキル習得処理を分岐
|
||
cheack_first_Lv = @level
|
||
cheack_first_Lv = @joblevel if KURE::BaseScript::USE_JOBLv == 1
|
||
|
||
#初期Lvで覚えるスキルを処理
|
||
self.class.learnings.each do |learning|
|
||
#スキルポイントシステムを利用している場合、初期スキルを制限する
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill(learning.skill_id) if learning.level <= cheack_first_Lv
|
||
end
|
||
else
|
||
learn_skill(learning.skill_id) if learning.level <= cheack_first_Lv
|
||
end
|
||
end
|
||
|
||
#職業レベルを導入している場合、Lv1固有スキルを処理する
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if $data_actors[@actor_id].actor_peculiar_skill != []
|
||
for i in 0..$data_actors[@actor_id].actor_peculiar_skill.size - 1
|
||
if i % 2 == 0
|
||
if @level >= $data_actors[@actor_id].actor_peculiar_skill[i]
|
||
learn_skill($data_actors[@actor_id].actor_peculiar_skill[i + 1])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#クラスレベルリストを更新する
|
||
add_level = @level
|
||
add_level = @joblevel if KURE::BaseScript::USE_JOBLv == 1
|
||
@classlevel_list[@class_id] = add_level
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲★◆ サブクラスの変更(追加定義)
|
||
# keep_exp : 経験値を引き継ぐ
|
||
#--------------------------------------------------------------------------
|
||
def change_sub_class(sub_class_id, keep_exp = true)
|
||
#転職前に習得スキルを保存する
|
||
@save_class_skills[@sub_class_id] = [] if @save_class_skills[@sub_class_id] == nil
|
||
@save_class_skills[@sub_class_id] = @sub_class_skills
|
||
|
||
@exp[class_id] = exp if keep_exp
|
||
@sub_class_id = sub_class_id
|
||
change_exp(@exp[@class_id] || 0, false, self.jobexp, self.sub_class_exp)
|
||
|
||
#転職後のスキルリストを確認する
|
||
@save_class_skills[@sub_class_id] = [] if @save_class_skills[@sub_class_id] == nil
|
||
|
||
#スキル削除モード時の処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if KURE::JobChange::DELETE_SKILL_MODE == 1
|
||
common_list = Array.new
|
||
for i in 0..@sub_class_skills.size - 1
|
||
if $data_skills[@sub_class_skills[i]].note.include?("<共有スキル>")
|
||
common_list.push(@skills[i])
|
||
end
|
||
end
|
||
|
||
@sub_class_skills = @save_class_skills[@sub_class_id]
|
||
@memory_skills = [] #スキルメモライズシステム
|
||
@extra_skills = [] #スキルメモライズシステム
|
||
|
||
for j in 0..common_list.size - 1
|
||
learn_skill_sub(common_list[j]) if KURE::BaseScript::USE_Skill_Point == 0
|
||
end
|
||
end
|
||
end
|
||
|
||
#職業レベルを併用している場合は職業レベルを設定
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
change_exp(self.exp, false, self.jobexp, @jobexp[@sub_class_id] || 0) if @sub_class_id != 0
|
||
end
|
||
|
||
#サブクラス設定時は初期Lvで覚えるスキルを処理
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if @sub_class_id != 0
|
||
$data_classes[@sub_class_id].learnings.each do |learning|
|
||
if KURE::BaseScript::USE_Skill_Point == 1
|
||
if learning.note.include?("<固有スキル>")
|
||
learn_skill_sub(learning.skill_id) if learning.level <= @sub_class_level
|
||
end
|
||
else
|
||
learn_skill_sub(learning.skill_id) if learning.level <= @sub_class_level
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#クラスレベルリストを更新する
|
||
@classlevel_list[@sub_class_id] = @sub_class_level if @sub_class_id != 0
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● HPの呼び出し(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def hp
|
||
@hp = [@hp,mhp].min
|
||
return @hp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● MPの呼び出し(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def mp
|
||
@mp = [@mp,mmp].min
|
||
return @mp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP増加量(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def all_gain_tp
|
||
gain_tp = 0
|
||
gain_tp += $data_actors[@actor_id].gain_tp[0] if $data_actors[@actor_id].gain_tp[1] == 0
|
||
gain_tp += self.class.gain_tp[0] if self.class.gain_tp[1] == 0
|
||
for i in 0..@equips.size - 1
|
||
#オブジェクトが存在している場合
|
||
if @equips[i].object != nil
|
||
if equip_slots[i] == 0
|
||
gain_tp += $data_weapons[@equips[i].id].gain_tp[0] if $data_weapons[@equips[i].id].gain_tp[1] == 0
|
||
else
|
||
gain_tp += $data_armors[@equips[i].id].gain_tp[0] if $data_armors[@equips[i].id].gain_tp[1] == 0
|
||
end
|
||
end
|
||
end
|
||
return gain_tp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP％増加量(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def all_gain_tp_per
|
||
gain_per = 100
|
||
gain_per += $data_actors[@actor_id].gain_tp[0] if $data_actors[@actor_id].gain_tp[1] == 1
|
||
gain_per += self.class.gain_tp[0] if self.class.gain_tp[1] == 1
|
||
for i in 0..@equips.size - 1
|
||
#オブジェクトが存在している場合
|
||
if @equips[i].object != nil
|
||
if equip_slots[i] == 0
|
||
gain_per += $data_weapons[@equips[i].id].gain_tp[0] if $data_weapons[@equips[i].id].gain_tp[1] == 1
|
||
else
|
||
gain_per += $data_armors[@equips[i].id].gain_tp[0] if $data_armors[@equips[i].id].gain_tp[1] == 1
|
||
end
|
||
end
|
||
end
|
||
return gain_per
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP の最大値を取得
|
||
#--------------------------------------------------------------------------
|
||
def max_tp
|
||
base = $data_classes[@class_id].base_tp
|
||
base += $data_actors[@actor_id].base_tp
|
||
add_fix = ($data_actors[@actor_id].tp_level_revise).to_f / 100
|
||
add = (add_fix * (@level - 1)).to_i
|
||
limit = $data_classes[@class_id].upper_limit_tp
|
||
|
||
if limit > ((base + add + all_gain_tp) * (all_gain_tp_per.to_f / 100)).to_i
|
||
return ((base + add + all_gain_tp) * (all_gain_tp_per.to_f / 100)).to_i
|
||
else
|
||
return limit
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP の割合を取得
|
||
#--------------------------------------------------------------------------
|
||
def tp_rate
|
||
return 0 if max_tp == 0
|
||
return @tp.to_f / max_tp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP の再生
|
||
#--------------------------------------------------------------------------
|
||
def regenerate_tp
|
||
self.tp += max_tp * trg
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ TP の初期化
|
||
#--------------------------------------------------------------------------
|
||
def init_tp
|
||
self.tp = rand * 25
|
||
|
||
tp_rate = passive_skills.select{|obj| obj.battle_start_tp != 0}.collect{|obj| obj.battle_start_tp}
|
||
tp_rate.flatten!
|
||
tp_rate.push(self.class.battle_start_tp)
|
||
tp_rate.push($data_actors[@actor_id].battle_start_tp)
|
||
final_rate = tp_rate.max
|
||
|
||
self.tp = max_tp * final_rate.to_f / 100 if final_rate != 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ 通常攻撃のスキル ID を取得
|
||
#--------------------------------------------------------------------------
|
||
def attack_skill_id
|
||
passive_list = passive_skills.select{|obj| obj.normal_attack_id != nil}.collect{|obj| obj.normal_attack_id}
|
||
passive_list.flatten!
|
||
if passive_list.size != 0
|
||
attack_skill = passive_list.sort_by{rand}
|
||
return attack_skill[0] if attack_skill[0]
|
||
end
|
||
|
||
if @equips[0].object != nil and equip_slots[0] == 0
|
||
if $data_weapons[@equips[0].id]
|
||
attack_skill = $data_weapons[@equips[0].id].normal_attack_id.sort_by{rand}
|
||
return attack_skill[0] if attack_skill[0]
|
||
end
|
||
end
|
||
|
||
if @equips[1].object != nil and equip_slots[1] == 0
|
||
if $data_weapons[@equips[1].id]
|
||
attack_skill = $data_weapons[@equips[1].id].normal_attack_id.sort_by{rand}
|
||
return attack_skill[0] if attack_skill[0]
|
||
end
|
||
end
|
||
|
||
attack_skill = $data_classes[@class_id].normal_attack_id.sort_by{rand}
|
||
return attack_skill[0] if attack_skill[0]
|
||
|
||
attack_skill = $data_actors[@actor_id].normal_attack_id.sort_by{rand}
|
||
return attack_skill[0] if attack_skill[0]
|
||
return 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ ステート情報をクリア(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias kure_before_clear_states clear_states
|
||
def clear_states
|
||
kure_before_clear_states
|
||
|
||
#パッシブスキルを更新する
|
||
if @actor_id
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ ステートの付加(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias kure_before_add_state add_state
|
||
def add_state(state_id)
|
||
kure_before_add_state(state_id)
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ ステートの解除(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias kure_before_remove_state remove_state
|
||
def remove_state(state_id)
|
||
kure_before_remove_state(state_id)
|
||
|
||
#パッシブスキルを更新する
|
||
set_passive_skills
|
||
release_unequippable_items
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ パーティ追加能力判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def party_add_ability(add_ability_id)
|
||
all_list = Array.new
|
||
sub = 100
|
||
|
||
actor = [$data_actors[@actor_id].party_add_ability[add_ability_id]]
|
||
sub = $data_classes[@sub_class_id].party_add_ability[add_ability_id] if @sub_class_id != 0
|
||
job = [$data_classes[@class_id].party_add_ability[add_ability_id],sub]
|
||
weapon = @equips.select{|obj| obj != nil && obj.is_weapon?}.collect{|obj| $data_weapons[obj.id].party_add_ability[add_ability_id]}
|
||
armor = @equips.select{|obj| obj != nil && obj.is_armor?}.collect{|obj| $data_armors[obj.id].party_add_ability[add_ability_id]}
|
||
passive = passive_skills.collect{|obj| obj.party_add_ability[add_ability_id]}
|
||
sta = states.collect{|obj| obj.party_add_ability[add_ability_id]}
|
||
all_list += actor + job + weapon + armor + passive + sta
|
||
all_list.flatten!
|
||
|
||
case add_ability_id
|
||
when 0,1,3,4,5
|
||
value = all_list.max.to_f / 100
|
||
when 2
|
||
value = all_list.inject(1) {|result, item| result * (item.to_f / 100) }
|
||
value.round(1)
|
||
end
|
||
return value
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 追加属性配列を取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def reflect_elements
|
||
reflect = Array.new
|
||
result = Array.new
|
||
|
||
weapon = @equips.select{|obj| obj != nil && obj.is_weapon? && $data_weapons[obj.id].reflect_elements}.collect{|obj| $data_weapons[obj.id].features}
|
||
armor = @equips.select{|obj| obj != nil && obj.is_armor? && $data_armors[obj.id].reflect_elements}.collect{|obj| $data_armors[obj.id].features}
|
||
reflect = weapon + armor
|
||
return result if reflect == []
|
||
|
||
for item in 0..reflect.size - 1
|
||
if reflect[item]
|
||
for ft in 0..reflect[item].size - 1
|
||
result.push(reflect[item][ft]) if reflect[item][ft]
|
||
end
|
||
end
|
||
end
|
||
return result if result == []
|
||
|
||
result = result.select {|ft| ft.code == 31}.inject([]) {|r, ft| r |= [ft.data_id] }
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの消費 金額 計算(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_gold_cost(skill)
|
||
skill.gold_cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの消費 アイテム配列の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_item_cost(skill)
|
||
list = skill.item_cost
|
||
item_cost = Array.new
|
||
for obj in 0..list.size - 1
|
||
if obj % 2 == 0
|
||
item_cost.push([list[obj],list[obj + 1]]) if list[obj + 1]
|
||
end
|
||
end
|
||
return item_cost
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ☆ スキルの必要 アイテム配列の取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_need_item(skill)
|
||
skill.need_used_item
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ スキルの必要武器を装備しているか(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def skill_wtype_ok?(skill)
|
||
wtype_id1 = skill.required_wtype_id1
|
||
wtype_id2 = skill.required_wtype_id2
|
||
#追加武器タイプ
|
||
wtype_id_add = skill.required_add_wtype_id
|
||
|
||
#要求武器タイプ
|
||
wtype_id_need = skill.need_wtype_id_all
|
||
|
||
#要求判定
|
||
if wtype_id_need != []
|
||
for need in 0..wtype_id_need.size - 1
|
||
if wtype_id_need[need] > 0
|
||
return false unless wtype_equipped?(wtype_id_need[need])
|
||
end
|
||
end
|
||
end
|
||
|
||
#二刀流要求の判定
|
||
return true if skill.need_two_weapon && weapons.size > 1
|
||
return false if skill.need_two_weapon && weapons.size < 2
|
||
|
||
return true if wtype_id1 == 0 && wtype_id2 == 0 && wtype_id_add == []
|
||
return true if wtype_id1 > 0 && wtype_equipped?(wtype_id1)
|
||
return true if wtype_id2 > 0 && wtype_equipped?(wtype_id2)
|
||
#追加判定
|
||
for add in 0..wtype_id_add.size - 1
|
||
if wtype_id_add[add]
|
||
return true if wtype_id_add[add] > 0 && wtype_equipped?(wtype_id_add[add])
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ リセットフラグ
|
||
#--------------------------------------------------------------------------
|
||
def reset_skill_flag
|
||
return true if @reset_skill_flag
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ リセットフラグ
|
||
#--------------------------------------------------------------------------
|
||
def reset_skill_flag=(value)
|
||
@reset_skill_flag = value
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Party(追加定義)
|
||
#==============================================================================
|
||
class Game_Party < Game_Unit
|
||
#--------------------------------------------------------------------------
|
||
# ● パーティ追加能力判定(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def party_add_ability(ability_id)
|
||
list = battle_members.collect{|actor| actor.party_add_ability(ability_id)}
|
||
list.flatten!
|
||
return list
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Player(再定義)
|
||
#==============================================================================
|
||
class Game_Player < Game_Character
|
||
#--------------------------------------------------------------------------
|
||
# ● エンカウント進行値の取得
|
||
#--------------------------------------------------------------------------
|
||
def encounter_progress_value
|
||
value = $game_map.bush?(@x, @y) ? 2 : 1
|
||
encount_rate = Array.new
|
||
encount_rate = $game_party.party_add_ability(2)
|
||
final_rate = encount_rate.inject(1) {|result, item| result * item}
|
||
value *= final_rate
|
||
value *= 0.5 if $game_party.encounter_half?
|
||
value *= 0.5 if in_ship?
|
||
value
|
||
end
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ Game_BaseItem(追加定義)
|
||
#==============================================================================
|
||
class Game_BaseItem
|
||
def id
|
||
@item_id
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Enemy
|
||
#==============================================================================
|
||
class Game_Enemy < Game_Battler
|
||
attr_accessor :steal
|
||
#--------------------------------------------------------------------------
|
||
# ● 職業経験値の取得
|
||
#--------------------------------------------------------------------------
|
||
def jobexp
|
||
enemy.jobexp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備経験値の取得
|
||
#--------------------------------------------------------------------------
|
||
def equip_exp
|
||
enemy.equip_exp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アビリティポイントの取得
|
||
#--------------------------------------------------------------------------
|
||
def ability_exp
|
||
enemy.ability_exp
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スティールリストの取得
|
||
#--------------------------------------------------------------------------
|
||
def steal_list
|
||
enemy.steal_list
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スティールの判定
|
||
#--------------------------------------------------------------------------
|
||
def non_stealed?
|
||
return true unless @steal
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ドロップアイテム取得率の倍率を取得
|
||
#--------------------------------------------------------------------------
|
||
def drop_item_rate
|
||
final_drop_rate = Array.new
|
||
final_drop_rate = $game_party.party_add_ability(1)
|
||
final_drop_rate.push(2) if $game_party.drop_item_double?
|
||
if $game_switches[228] == true#紅茶走
|
||
max_rate = 0 #紅茶走
|
||
else #紅茶走
|
||
max_rate = $game_variables[499]/100.0 #紅茶走
|
||
end#紅茶走
|
||
return max_rate
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Troop
|
||
#==============================================================================
|
||
class Game_Troop < Game_Unit
|
||
#--------------------------------------------------------------------------
|
||
# ● 経験値の合計計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def exp_total
|
||
exp_total = dead_members.inject(0) {|r, enemy| r += enemy.exp }
|
||
exp_rate = $game_party.party_add_ability(3)
|
||
exp_total *= exp_rate.max
|
||
if KURE::BaseScript::USE_PartyEdit == 1
|
||
if KURE::PartyEdit::SHARE_EXP_MODE == 1
|
||
max = $game_party.max_battle_members
|
||
now = $game_party.battle_members_size
|
||
ptm_rate = 1 + max.to_f / now
|
||
exp_total *= ptm_rate
|
||
end
|
||
end
|
||
return exp_total.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 職業経験値の合計計算(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def jobexp_total
|
||
jobexp_total = dead_members.inject(0) {|r, enemy| r += enemy.jobexp }
|
||
jobexp_rate = $game_party.party_add_ability(4)
|
||
jobexp_total *= jobexp_rate.max
|
||
if KURE::BaseScript::USE_PartyEdit == 1
|
||
if KURE::PartyEdit::SHARE_EXP_MODE == 1
|
||
max = $game_party.max_battle_members
|
||
now = $game_party.battle_members_size
|
||
ptm_rate = 1 + max.to_f / now
|
||
jobexp_total *= ptm_rate
|
||
end
|
||
end
|
||
return jobexp_total.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備経験値の合計計算(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def equip_exp_total
|
||
equip_exp_total = dead_members.inject(0) {|r, enemy| r += enemy.equip_exp }
|
||
equip_exp_rate = $game_party.party_add_ability(5)
|
||
equip_exp_total *= equip_exp_rate.max
|
||
if KURE::BaseScript::USE_PartyEdit == 1
|
||
if KURE::PartyEdit::SHARE_EXP_MODE == 1
|
||
max = $game_party.max_battle_members
|
||
now = $game_party.battle_members_size
|
||
ptm_rate = 1 + max.to_f / now
|
||
equip_exp_total *= ptm_rate
|
||
end
|
||
end
|
||
return equip_exp_total.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アビリティポイントの合計計算(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def ability_exp_total
|
||
ability_exp_total = dead_members.inject(0) {|r, enemy| r += enemy.ability_exp }
|
||
return ability_exp_total.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● お金の合計計算(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def gold_total
|
||
(dead_members.inject(0) {|r, enemy| r += enemy.gold } * gold_rate).to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● お金の倍率を取得(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def gold_rate
|
||
final_gold_rate = Array.new
|
||
final_gold_rate = $game_party.party_add_ability(0)
|
||
final_gold_rate.push(2) if $game_party.gold_double?
|
||
max_rate = final_gold_rate.max
|
||
return max_rate
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Action
|
||
#==============================================================================
|
||
class Game_Action
|
||
#--------------------------------------------------------------------------
|
||
# ● ランダムオブジェクト取得
|
||
#--------------------------------------------------------------------------
|
||
def random_item
|
||
return @random_item if @ramdom_effect == 1
|
||
return nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルを設定(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias k_basescript_before_set_skill set_skill
|
||
def set_skill(skill_id)
|
||
@ramdom_effect = 0
|
||
if $data_skills[skill_id].random_skill_effect != []
|
||
select_skill = $data_skills[skill_id].random_skill_effect.sort_by{rand}
|
||
@random_item = $data_skills[select_skill[0]]
|
||
@ramdom_effect = 1
|
||
end
|
||
k_basescript_before_set_skill(skill_id)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アイテムを設定(エイリアス再定義)
|
||
#--------------------------------------------------------------------------
|
||
alias k_basescript_before_set_item set_item
|
||
def set_item(item_id)
|
||
@ramdom_effect = 0
|
||
if $data_items[item_id].random_item_effect != []
|
||
select_item = $data_items[item_id].random_item_effect.sort_by{rand}
|
||
@random_item = $data_items[select_item[0]]
|
||
@ramdom_effect = 1
|
||
end
|
||
|
||
k_basescript_before_set_item(item_id)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 行動が有効か否かの判定
|
||
# イベントコマンドによる [戦闘行動の強制] ではないとき、ステートの制限
|
||
# やアイテム切れなどで予定の行動ができなければ false を返す。
|
||
#--------------------------------------------------------------------------
|
||
def valid?
|
||
return true if @ramdom_effect == 1
|
||
(forcing && item) || subject.usable?(item)
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_ActionResult(追加定義)
|
||
#==============================================================================
|
||
class Game_ActionResult
|
||
#--------------------------------------------------------------------------
|
||
# ● 追加インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :use_steal # スティールフラグ
|
||
attr_accessor :steal # スティールフラグ
|
||
attr_accessor :stealed # スティールフラグ
|
||
attr_accessor :auto_stand # 踏みとどまりフラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● クリア
|
||
#--------------------------------------------------------------------------
|
||
alias k_basescript_before_clear clear
|
||
def clear
|
||
k_basescript_before_clear
|
||
clear_steal
|
||
clear_stand
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スティールフラグのクリア
|
||
#--------------------------------------------------------------------------
|
||
def clear_steal
|
||
@use_steal = false
|
||
@steal = false
|
||
@stealed = false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 踏みとどまりフラグのクリア
|
||
#--------------------------------------------------------------------------
|
||
def clear_stand
|
||
@auto_stand = false
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Scene_Battle(再定義)
|
||
#==============================================================================
|
||
class Scene_Battle < Scene_Base
|
||
#--------------------------------------------------------------------------
|
||
|
||
|
||
|
||
# ● スキル／アイテムの使用(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def use_item
|
||
#オートリザレクション、踏みとどまり配列を作成
|
||
auto_revive_battler = Array.new
|
||
all_battle_members.each do |battler|
|
||
if battler.auto_revive
|
||
auto_revive_battler.push([battler,battler.auto_revive])
|
||
end
|
||
end
|
||
|
||
item = @subject.current_action.item
|
||
random = @subject.current_action.random_item
|
||
@log_window.display_use_item(@subject, item)
|
||
@subject.use_item(item)
|
||
|
||
item = random if random
|
||
|
||
refresh_status
|
||
targets = @subject.current_action.make_targets.compact
|
||
show_animation(targets, item.animation_id)
|
||
targets.each {|target| item.repeats.times { invoke_item(target, item) } }
|
||
|
||
#自爆スキル判定
|
||
if item.is_a?(RPG::Skill) && item.life_cost
|
||
@log_window.display_paylife_message(@subject, item)
|
||
@subject.pay_life(item)
|
||
refresh_status
|
||
wait_for_effect
|
||
end
|
||
|
||
#オートリザレクション実行
|
||
auto_revive_battler.each do |battler_list|
|
||
@log_window.display_autorevive_message(battler_list[0])
|
||
battler_list[0].revive_life(battler_list[1])
|
||
refresh_status
|
||
@log_window.wait_and_clear
|
||
end
|
||
|
||
@log_window.clear
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターン終了
|
||
#--------------------------------------------------------------------------
|
||
def turn_end
|
||
#オートリザレクション配列を作成
|
||
auto_revive_battler = Array.new
|
||
all_battle_members.each do |battler|
|
||
if battler.auto_revive
|
||
auto_revive_battler.push([battler,battler.auto_revive])
|
||
end
|
||
end
|
||
|
||
all_battle_members.each do |battler|
|
||
battler.on_turn_end
|
||
refresh_status
|
||
@log_window.display_auto_affected_status(battler)
|
||
@log_window.wait_and_clear
|
||
end
|
||
|
||
#オートリザレクション実行
|
||
auto_revive_battler.each do |battler_list|
|
||
@log_window.display_autorevive_message(battler_list[0])
|
||
battler_list[0].revive_life(battler_list[1])
|
||
refresh_status
|
||
@log_window.wait_and_clear
|
||
end
|
||
|
||
BattleManager.turn_end
|
||
process_event
|
||
start_party_command_selection
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ▲ BattleManager(再定義)
|
||
#==============================================================================
|
||
module BattleManager
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 獲得した経験値の表示(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def self.display_exp
|
||
#Exp
|
||
if $game_troop.exp_total > 0
|
||
text = sprintf(Vocab::ObtainExp, $game_troop.exp_total)
|
||
$game_message.add('\.' + text)
|
||
end
|
||
|
||
#JobExp
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if $game_troop.jobexp_total > 0
|
||
text2 = sprintf(Vocab::ObtainJobExp, $game_troop.jobexp_total)
|
||
$game_message.add('\.' + text2)
|
||
end
|
||
end
|
||
|
||
#EquipExp
|
||
if KURE::BaseScript::USE_SortOut == 1
|
||
if $game_troop.equip_exp_total > 0
|
||
text3 = sprintf(Vocab::ObtainEquipExp, $game_troop.equip_exp_total)
|
||
$game_message.add('\.' + text3)
|
||
end
|
||
end
|
||
|
||
#AP
|
||
if $game_troop.ability_exp_total > 0
|
||
text4 = sprintf(Vocab::ObtainAP, $game_troop.ability_exp_total)
|
||
$game_message.add('\.' + text4)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ▲ 経験値の獲得とレベルアップの表示(再定義)
|
||
#--------------------------------------------------------------------------
|
||
def self.gain_exp
|
||
base = $game_troop.exp_total
|
||
job = 0
|
||
job = $game_troop.jobexp_total if KURE::BaseScript::USE_JOBLv == 1
|
||
equip = 0
|
||
equip = $game_troop.equip_exp_total if KURE::BaseScript::USE_SortOut == 1
|
||
ap = 0
|
||
ap = $game_troop.ability_exp_total
|
||
|
||
$game_party.all_members.each do |actor|
|
||
actor.gain_exp(base, job, equip, ap)
|
||
end
|
||
wait_for_message
|
||
end
|
||
end |