1881 lines
No EOL
69 KiB
Ruby
1881 lines
No EOL
69 KiB
Ruby
#==============================================================================
|
||
# ■スキルポイントシステム for RGSS3 Ver1.12-β3
|
||
# □author kure
|
||
#
|
||
# 呼び出し方法 SceneManager.call(Scene_SkillPoint)
|
||
#
|
||
#==============================================================================
|
||
module KURE
|
||
module SkillPoint
|
||
#スキルポイントに関する設定-------------------------------------------------
|
||
#基礎スキルポイントの値
|
||
BASE_SKILL_POINT = 0
|
||
|
||
#表示に関する設定-----------------------------------------------------------
|
||
#未開放スキルの表示名
|
||
VIEW_LOCK_SKILL_NAME = "？？？？？？"
|
||
#表示しないスキルタイプの設定
|
||
#NOT_VIEW_SKILLTYPE = [スキルタイプID]
|
||
NOT_VIEW_SKILLTYPE = []
|
||
#スキルLv表示タイプ(0=習得スキルのLv 1=現在のスキルLv 2=消費ポイントの表示)
|
||
VIEW_SKILL_Lv_MODE = 1
|
||
#ポップアップの表示(0=表示しない 1=表示する)
|
||
VIEW_POPUP = 1
|
||
#インフォメーションウィンドウの表示(0=表示しない 1=表示する)
|
||
VIEW_INFOMATION = 1
|
||
|
||
#動作に関する設定-----------------------------------------------------------
|
||
#スキルポイント回収「←キー」の有効設定
|
||
#USE_LEFT_KEY = [有効にするスキルID配列]
|
||
USE_LEFT_KEY = [1,]
|
||
|
||
#消費スキルポイントに関する設定---------------------------------------------
|
||
#基本消費ポイント(消費スキルポイントが設定されていないスキル)
|
||
#BASE_USE_POINT_MODE(0=1ポイント 1=スキルLvと同一
|
||
BASE_USE_POINT_MODE = 0
|
||
|
||
#スキルポイントの名称
|
||
Skill_Point_NAME = "JOBEXP"
|
||
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Actor(再定義)
|
||
#==============================================================================
|
||
class Game_Actor < Game_Battler
|
||
#--------------------------------------------------------------------------
|
||
# ● 最大スキルポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def max_skillpoint(class_id)
|
||
max_skillpoint = 0
|
||
#基礎スキルポイントを加算
|
||
max_skillpoint += KURE::SkillPoint::BASE_SKILL_POINT
|
||
#レベル補正を加算
|
||
max_skillpoint += $data_actors[@actor_id].skillpoint_level_revise * @level
|
||
|
||
#職業レベル補正を加算
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
max_skillpoint += $data_actors[@actor_id].skillpoint_joblevel_revise * @joblevel
|
||
end
|
||
#アクター補正を加算
|
||
max_skillpoint += $data_actors[@actor_id].skillpoint_revise
|
||
#変数補正を加算
|
||
if $data_actors[@actor_id].add_max_skillpoint_var != 0
|
||
max_skillpoint += $game_variables[$data_actors[@actor_id].add_max_skillpoint_var]
|
||
end
|
||
|
||
return max_skillpoint.to_i
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費中スキルポイントの定義(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def used_skill_points(class_id)
|
||
@used_skill_point = [] if @used_skill_point.instance_of?(Array) == false
|
||
@used_skill_point[class_id] = 0 if @used_skill_point[class_id] == nil
|
||
@used_skill_point[class_id]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントの消費(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def use_skill_point(class_id,point)
|
||
@used_skill_point[class_id] += point
|
||
@used_skill_point[class_id] = 0 if @used_skill_point[class_id] < 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポイント振り分けメインクラスのスキルの配列取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def point_skills
|
||
result = Array.new
|
||
level = self.class.learnings.collect {|learning| learning.level}
|
||
skill = self.class.learnings.collect {|learning| $data_skills[learning.skill_id]}
|
||
note = self.class.learnings.collect {|learning| learning.note}
|
||
|
||
#ツリーID保存用配列を作成
|
||
tree_id = Array.new
|
||
#ツリーID保存用配列を作成
|
||
tree_id = Array.new
|
||
for i in 0..note.size - 1
|
||
tree_id[i] = 0
|
||
#スキルのメモ欄からスキルツリーIDを取得する
|
||
note[i].match(/<([FM])ツリー\s?(\d+)>/)
|
||
if $1
|
||
case $1.upcase
|
||
when "F"
|
||
tree_id[i] = $2.to_i
|
||
when "M"
|
||
tree_id[i] = $2.to_i * -1
|
||
end
|
||
end
|
||
end
|
||
|
||
#消費スキルポイント保存用配列を作成
|
||
use_point = Array.new
|
||
for i in 0..note.size - 1
|
||
#スキルのメモ欄から消費スキルポイントを取得する
|
||
note[i].match(/<消費SP\s?(\d+)>/)
|
||
if $1 == nil
|
||
use_point[i] = 1
|
||
use_point[i] = level[i] if KURE::SkillPoint::BASE_USE_POINT_MODE == 1
|
||
else
|
||
use_point[i] = $1.to_i
|
||
end
|
||
end
|
||
|
||
#前提スキル保存用の配列を作成
|
||
skill_list = Array.new
|
||
for i in 0..note.size - 1
|
||
#メモ欄から配列を作成
|
||
list = note[i].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)}
|
||
skill_list[i] = save_list
|
||
end
|
||
end
|
||
|
||
#固有スキルのチェック
|
||
uniq_list = Array.new
|
||
for i in 0..note.size - 1
|
||
if note[i].include?("<固有スキル>")
|
||
uniq_list[i] = 1
|
||
else
|
||
uniq_list[i] = 0
|
||
end
|
||
end
|
||
|
||
#非公開スキルのチェック
|
||
mask_list = Array.new
|
||
for i in 0..note.size - 1
|
||
if note[i].include?("<非公開表示>")
|
||
mask_list[i] = 1
|
||
else
|
||
mask_list[i] = 0
|
||
end
|
||
end
|
||
|
||
#要求レベルのチェック
|
||
request_lv = Array.new
|
||
for i in 0..note.size - 1
|
||
note[i].match(/<要求レベル\s?(\d+),\s?(\d+)>/)
|
||
request_lv[i] = []
|
||
request_lv[i][0] = 0
|
||
request_lv[i][1] = 0
|
||
request_lv[i][0] = $1.to_i if $1 != nil
|
||
request_lv[i][1] = $2.to_i if $2 != nil
|
||
end
|
||
|
||
#サブツリー保存用の配列を作成
|
||
sub_tree = Array.new
|
||
for i in 0..note.size - 1
|
||
#スキルのメモ欄からスキルツリーIDを取得する
|
||
note[i].match(/<サブ\s?(\d+)>/)
|
||
if $1 == nil
|
||
sub_tree[i] = 0
|
||
else
|
||
#ツリーが設定されている場合は数字を返す
|
||
sub_tree[i] = $1.to_i
|
||
end
|
||
end
|
||
|
||
for i in 0..skill.size - 1
|
||
if uniq_list[i] == 0
|
||
skill_ary = [level[i],skill[i],tree_id[i],use_point[i],skill_list[i],mask_list[i],request_lv[i],sub_tree[i]]
|
||
result[i] = skill_ary
|
||
end
|
||
end
|
||
|
||
result.compact!
|
||
|
||
return result
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポイント振り分けサブクラスのスキルの配列取得(追加定義)
|
||
#--------------------------------------------------------------------------
|
||
def point_skills_sub
|
||
result = Array.new
|
||
level = self.sub_class.learnings.collect {|learning| learning.level}
|
||
skill = self.sub_class.learnings.collect {|learning| $data_skills[learning.skill_id]}
|
||
note = self.sub_class.learnings.collect {|learning| learning.note}
|
||
|
||
#ツリーID保存用配列を作成
|
||
tree_id = Array.new
|
||
for i in 0..note.size - 1
|
||
tree_id[i] = 0
|
||
#スキルのメモ欄からスキルツリーIDを取得する
|
||
note[i].match(/<([FM])ツリー\s?(\d+)>/)
|
||
if $1 != nil
|
||
case $1.upcase
|
||
when "F"
|
||
tree_id[i] = $2.to_i
|
||
when "M"
|
||
tree_id[i] = $2.to_i * -1
|
||
end
|
||
end
|
||
end
|
||
|
||
#消費スキルポイント保存用配列を作成
|
||
use_point = Array.new
|
||
for i in 0..note.size - 1
|
||
#スキルのメモ欄から消費スキルポイントを取得する
|
||
note[i].match(/<消費SP\s?(\d+)>/)
|
||
if $1 == nil
|
||
use_point[i] = 5
|
||
use_point[i] = level[i] if KURE::SkillPoint::BASE_USE_POINT_MODE == 0
|
||
else
|
||
use_point[i] = $1.to_i
|
||
end
|
||
end
|
||
|
||
#前提スキル保存用の配列を作成
|
||
skill_list = Array.new
|
||
for i in 0..note.size - 1
|
||
#メモ欄から配列を作成
|
||
list = note[i].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)}
|
||
skill_list[i] = save_list
|
||
end
|
||
end
|
||
|
||
#固有スキルのチェック
|
||
uniq_list = Array.new
|
||
for i in 0..note.size - 1
|
||
if note[i].include?("<固有スキル>")
|
||
uniq_list[i] = 1
|
||
else
|
||
uniq_list[i] = 0
|
||
end
|
||
end
|
||
|
||
#非公開スキルのチェック
|
||
mask_list = Array.new
|
||
for i in 0..note.size - 1
|
||
if note[i].include?("<非公開表示>")
|
||
mask_list[i] = 1
|
||
else
|
||
mask_list[i] = 0
|
||
end
|
||
end
|
||
|
||
#要求レベルのチェック
|
||
request_lv = Array.new
|
||
for i in 0..note.size - 1
|
||
note[i].match(/<要求レベル\s?(\d+),\s?(\d+)>/)
|
||
request_lv[i] = []
|
||
request_lv[i][0] = 0
|
||
request_lv[i][1] = 0
|
||
request_lv[i][0] = $1.to_i if $1 != nil
|
||
request_lv[i][1] = $2.to_i if $2 != nil
|
||
end
|
||
|
||
#サブツリー保存用の配列を作成
|
||
sub_tree = Array.new
|
||
for i in 0..note.size - 1
|
||
#スキルのメモ欄からスキルツリーIDを取得する
|
||
note[i].match(/<サブ\s?(\d+)>/)
|
||
if $1 == nil
|
||
sub_tree[i] = 0
|
||
else
|
||
#ツリーが設定されている場合は数字を返す
|
||
sub_tree[i] = $1.to_i
|
||
end
|
||
end
|
||
|
||
for i in 0..skill.size - 1
|
||
if uniq_list[i] == 0
|
||
skill_ary = [level[i],skill[i],tree_id[i],use_point[i],skill_list[i],mask_list[i],request_lv[i],sub_tree[i]]
|
||
result[i] = skill_ary
|
||
end
|
||
end
|
||
|
||
result.compact!
|
||
|
||
return result
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Scene_SkillPoint
|
||
#==============================================================================
|
||
class Scene_SkillPoint < Scene_MenuBase
|
||
#--------------------------------------------------------------------------
|
||
# ● 開始処理
|
||
#--------------------------------------------------------------------------
|
||
def start
|
||
super
|
||
@used_reset_flag = Array.new
|
||
@used_reset_flag.push(@actor.id)
|
||
|
||
create_help_window
|
||
create_pop_window
|
||
create_small_status_window
|
||
create_class_select_window
|
||
create_info_window
|
||
create_skilltype_window
|
||
create_skill_point_window
|
||
|
||
window_setting
|
||
|
||
@last_skill_type_index = -1
|
||
|
||
|
||
if KURE::BaseScript::USE_JOBLv == 1 && @actor.sub_class_id != 0
|
||
@class_select_window.activate
|
||
else
|
||
@class_select_window.deactivate
|
||
@class_select_window.hide
|
||
@skill_type_window.activate
|
||
@skill_type_window.select(0)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポップアップウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_pop_window
|
||
wx = Graphics.width / 4
|
||
wy = Graphics.height / 3
|
||
width = Graphics.width / 2
|
||
height = 24 * 6
|
||
@pop_up_window = Window_k_SkillPoint_PopupWindow.new(wx,wy,width,height)
|
||
@pop_up_window.z += 100
|
||
@pop_up_window.back_opacity = 255
|
||
@pop_up_window.refresh
|
||
@pop_up_window.hide
|
||
|
||
@decide_window = Window_k_SkillPoint_DecideCommand.new(wx,wy + height - 48,width,48)
|
||
@decide_window.opacity = 0
|
||
@decide_window.z += 100
|
||
@decide_window.deactivate
|
||
@decide_window.hide
|
||
|
||
#ハンドラのセット
|
||
@decide_window.set_handler(:cancel, method(:pop_up_cancel))
|
||
@decide_window.set_handler(:ok, method(:pop_up_ok))
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ステータスウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_small_status_window
|
||
wx = 0
|
||
wy = @help_window.height
|
||
@small_status_window = Window_k_SkillPoint_Small_Status.new(wx,wy,260,144)
|
||
@small_status_window.viewport = @viewport
|
||
@small_status_window.actor = @actor
|
||
@small_status_window.refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 職業クラス選択ウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_class_select_window
|
||
wx = 0
|
||
wy = @help_window.height + @small_status_window.height
|
||
@class_select_window = Window_k_SkillPoint_Class_Grade_Command.new(wx,wy,260)
|
||
@class_select_window.actor = @actor
|
||
|
||
#ハンドラのセット
|
||
@class_select_window.set_handler(:cancel, method(:return_scene))
|
||
@class_select_window.set_handler(:ok, method(:class_select_ok))
|
||
@class_select_window.set_handler(:pagedown, method(:next_actor))
|
||
@class_select_window.set_handler(:pageup, method(:prev_actor))
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_info_window
|
||
wx = 0
|
||
wh = 48
|
||
wy = Graphics.height - wh
|
||
ww = Graphics.width
|
||
|
||
@info_window = Window_k_Infomation_Window.new(wx, wy, ww, wh)
|
||
if KURE::SkillPoint::VIEW_INFOMATION == 0
|
||
@info_window.height = 0
|
||
@info_window.hide
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スロットウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_skilltype_window
|
||
wx = 0
|
||
wy = @help_window.height + @small_status_window.height
|
||
wy += @class_select_window.height if KURE::BaseScript::USE_JOBLv == 1 && @actor.sub_class_id != 0
|
||
width = @small_status_window.width
|
||
height = Graphics.height - wy - @info_window.height
|
||
@skill_type_window = Window_k_SkillPoint_SkillCommand.new(wx, wy, width, height)
|
||
@skill_type_window.actor = @actor
|
||
@skill_type_window.deactivate
|
||
@skill_type_window.unselect
|
||
|
||
#ハンドラのセット
|
||
@skill_type_window.set_handler(:cancel, method(:skill_type_cancel))
|
||
@skill_type_window.set_handler(:ok, method(:skill_type_ok))
|
||
@skill_type_window.set_handler(:pagedown, method(:next_actor))
|
||
@skill_type_window.set_handler(:pageup, method(:prev_actor))
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントウィンドウの作成
|
||
#--------------------------------------------------------------------------
|
||
def create_skill_point_window
|
||
wx = @small_status_window.width
|
||
wy = @help_window.height
|
||
ww = Graphics.width - wx
|
||
wh = Graphics.height - wy - @info_window.height
|
||
@skill_point_window = Window_k_SkillPoint_SkillList.new(wx, wy, ww, wh)
|
||
@skill_point_window.viewport = @viewport
|
||
@skill_point_window.actor = @actor
|
||
|
||
@skill_point_window.deactivate
|
||
@skill_point_window.unselect
|
||
|
||
#ハンドラのセット
|
||
@skill_point_window.set_handler(:ok, method(:skill_point_ok))
|
||
@skill_point_window.set_handler(:cancel, method(:skill_point_cancel))
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウのセット
|
||
#--------------------------------------------------------------------------
|
||
def window_setting
|
||
@pop_up_window.skill_point_window = @skill_point_window
|
||
|
||
@class_select_window.skill_type_window = @skill_type_window
|
||
@class_select_window.skill_point_window = @skill_point_window
|
||
@class_select_window.status_window = @small_status_window
|
||
|
||
@skill_point_window.status_window = @small_status_window
|
||
@skill_point_window.help_window = @help_window
|
||
@skill_point_window.pop_up_window = @pop_up_window
|
||
@skill_point_window.decide_window = @decide_window
|
||
@skill_point_window.info_window = @info_window
|
||
|
||
@skill_type_window.skill_point_window = @skill_point_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポップアップを閉じる
|
||
#--------------------------------------------------------------------------
|
||
def pop_up_close
|
||
@pop_up_window.hide
|
||
@decide_window.hide
|
||
@decide_window.unselect
|
||
@skill_point_window.activate
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポップアップウィンドウ[決定]
|
||
#--------------------------------------------------------------------------
|
||
def pop_up_ok
|
||
case @decide_window.index
|
||
when 0
|
||
@skill_point_window.pop_up_skill_learn
|
||
pop_up_close
|
||
when 1
|
||
pop_up_close
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポップアップウィンドウ[キャンセル]
|
||
#--------------------------------------------------------------------------
|
||
def pop_up_cancel
|
||
pop_up_close
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● クラスセレクトウィンドウ[決定]
|
||
#--------------------------------------------------------------------------
|
||
def class_select_ok
|
||
@class_select_window.deactivate
|
||
@skill_type_window.select(0)
|
||
@skill_type_window.activate
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルタイプウィンドウ[決定]
|
||
#--------------------------------------------------------------------------
|
||
def skill_type_ok
|
||
@skill_point_window.stype_id = @skill_type_window.current_ext
|
||
skill_type_to_skill_point
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルタイプウィンドウ[キャンセル]
|
||
#--------------------------------------------------------------------------
|
||
def skill_type_cancel
|
||
skill_type_to_class_select
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントウィンドウ[決定]
|
||
#--------------------------------------------------------------------------
|
||
def skill_point_ok
|
||
@skill_point_window.view_pop_up
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントウィンドウ[キャンセル]
|
||
#--------------------------------------------------------------------------
|
||
def skill_point_cancel
|
||
skill_point_to_skill_type
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルタイプ→クラスセレクトウィンドウ切り替え
|
||
#--------------------------------------------------------------------------
|
||
def skill_type_to_class_select
|
||
if KURE::BaseScript::USE_JOBLv == 1 && @actor.sub_class_id != 0
|
||
@skill_type_window.unselect
|
||
@skill_type_window.deactivate
|
||
@class_select_window.activate
|
||
else
|
||
reset_all_flag
|
||
return_scene
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フラグの全消去
|
||
#--------------------------------------------------------------------------
|
||
def reset_all_flag
|
||
for actor in 0..@used_reset_flag.size - 1
|
||
if @used_reset_flag[actor]
|
||
$game_actors[@used_reset_flag[actor]].reset_skill_flag = false
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルタイプ→スキルポイントウィンドウ切り替え
|
||
#--------------------------------------------------------------------------
|
||
def skill_type_to_skill_point
|
||
@last_skill_type_index = @skill_type_window.index
|
||
@skill_type_window.unselect
|
||
@skill_type_window.deactivate
|
||
@skill_point_window.select(0)
|
||
@skill_point_window.activate
|
||
@skill_point_window.refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイント→スキルタイプウィンドウ切り替え
|
||
#--------------------------------------------------------------------------
|
||
def skill_point_to_skill_type
|
||
@skill_point_window.select(0)
|
||
@skill_point_window.unselect
|
||
@skill_point_window.deactivate
|
||
@skill_point_window.update_help
|
||
@skill_type_window.activate
|
||
@skill_type_window.index = @last_skill_type_index
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次のアクターに切り替え
|
||
#--------------------------------------------------------------------------
|
||
def next_actor
|
||
@actor.set_passive_skills
|
||
@actor.release_unequippable_items
|
||
@actor = $game_party.menu_actor_next
|
||
on_actor_change
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 前のアクターに切り替え
|
||
#--------------------------------------------------------------------------
|
||
def prev_actor
|
||
@actor.set_passive_skills
|
||
@actor.release_unequippable_items
|
||
@actor = $game_party.menu_actor_prev
|
||
on_actor_change
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクターの切り替え
|
||
#--------------------------------------------------------------------------
|
||
def on_actor_change
|
||
@skill_point_window.actor = @actor
|
||
@skill_type_window.actor = @actor
|
||
@small_status_window.actor = @actor
|
||
@class_select_window.actor = @actor
|
||
@class_select_window.select(0)
|
||
@used_reset_flag.push(@actor.id)
|
||
|
||
if KURE::BaseScript::USE_JOBLv == 1 && @actor.sub_class_id != 0
|
||
@class_select_window.show
|
||
@class_select_window.activate
|
||
|
||
wy = @help_window.height + @small_status_window.height + @class_select_window.height
|
||
@skill_type_window.y = wy
|
||
@skill_type_window.height = Graphics.height - wy - @info_window.height
|
||
@skill_type_window.unselect
|
||
@skill_type_window.deactivate
|
||
@skill_type_window.refresh
|
||
else
|
||
@class_select_window.hide
|
||
@class_select_window.deactivate
|
||
|
||
wy = @help_window.height + @small_status_window.height
|
||
@skill_type_window.y = wy
|
||
@skill_type_window.height = Graphics.height - wy - @info_window.height
|
||
@skill_type_window.select(0)
|
||
@skill_type_window.activate
|
||
@skill_type_window.refresh
|
||
end
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_Small_Status
|
||
#------------------------------------------------------------------------------
|
||
# メニュー画面でパーティメンバーのステータスを表示するウィンドウです。
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_Small_Status < Window_Selectable
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :pending_index # 保留位置（並び替え用）
|
||
attr_accessor :actor
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y,width,height)
|
||
super(x, y, width, height)
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクターの設定
|
||
#--------------------------------------------------------------------------
|
||
def actor=(actor)
|
||
return if @actor == actor
|
||
@actor = actor
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 描画するクラス の設定
|
||
#--------------------------------------------------------------------------
|
||
def draw_class=(draw_class)
|
||
return if @draw_class == draw_class
|
||
@draw_class = draw_class
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 項目の描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_status
|
||
return unless @actor
|
||
draw_actor_face(@actor, 0, 12)
|
||
draw_actor_name(@actor, 100, line_height * 0)
|
||
draw_actor_class(@actor, 100, line_height * 1)
|
||
draw_actor_level(@actor, 100, line_height * 2)
|
||
draw_actor_skill_point(@actor, 100, line_height * 3)
|
||
#draw_text(100, line_height * 4, 200, line_height, "☆") if @actor.reset_skill_flag
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイントの描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_actor_skill_point(actor, x, y, width = 120)
|
||
view_class_id = 0
|
||
view_class_id = @actor.class_id
|
||
view_class_id = @actor.sub_class_id if @draw_class == 1
|
||
|
||
return if view_class_id == 0
|
||
@skill_point_n = @actor.used_skill_points(view_class_id)
|
||
@max_skill_point_m = @actor.max_skillpoint(view_class_id)
|
||
|
||
skill_rate = @skill_point_n.to_f / @max_skill_point_m
|
||
draw_gauge(x, y, width, skill_rate, tp_gauge_color1, tp_gauge_color2)
|
||
change_color(system_color)
|
||
draw_text(x, y, 30, line_height, KURE::SkillPoint::Skill_Point_NAME)
|
||
draw_current_and_max_values(x, y, width, @skill_point_n, @max_skill_point_m,
|
||
mp_color(actor), normal_color)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● リフレッシュ
|
||
#--------------------------------------------------------------------------
|
||
def refresh
|
||
contents.clear
|
||
draw_status
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_SkillList(新規)
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_SkillList < Window_Command
|
||
attr_accessor :data
|
||
attr_accessor :status_window
|
||
attr_accessor :pop_up_window
|
||
attr_accessor :decide_window
|
||
attr_accessor :info_window
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y,width,height)
|
||
@select_skill = 0
|
||
@stype_id = 0
|
||
@width = width
|
||
@height = height
|
||
@draw_class = 0
|
||
super(x, y)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 描画するクラス の設定
|
||
#--------------------------------------------------------------------------
|
||
def draw_class=(draw_class)
|
||
return if @draw_class == draw_class
|
||
@draw_class = draw_class
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ幅の取得
|
||
#--------------------------------------------------------------------------
|
||
def window_width
|
||
return @width
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ高さの取得
|
||
#--------------------------------------------------------------------------
|
||
def window_height
|
||
return @height
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルレベル
|
||
#--------------------------------------------------------------------------
|
||
def skill_lv(skill)
|
||
return skill[0]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの取得
|
||
#--------------------------------------------------------------------------
|
||
def item
|
||
@data[index] && index >= 0 ? @data[index][1] : nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ツリーID
|
||
#--------------------------------------------------------------------------
|
||
def tree_id(skill)
|
||
return skill[2]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 消費スキルポイント
|
||
#--------------------------------------------------------------------------
|
||
def use_select_point(skill)
|
||
return skill[3]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 要求レベル
|
||
#--------------------------------------------------------------------------
|
||
def need_lv(skill)
|
||
return skill[6][0]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 要求職業レベル
|
||
#--------------------------------------------------------------------------
|
||
def need_joblv(skill)
|
||
return skill[6][1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● サブツリーID
|
||
#--------------------------------------------------------------------------
|
||
def sub_tree_id(skill)
|
||
return skill[7]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクターの設定
|
||
#--------------------------------------------------------------------------
|
||
def actor=(actor)
|
||
return if @actor == actor
|
||
@actor = actor
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルタイプ ID の設定
|
||
#--------------------------------------------------------------------------
|
||
def stype_id=(stype_id)
|
||
return if @stype_id == stype_id
|
||
@stype_id = stype_id
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 描画するクラス の設定
|
||
#--------------------------------------------------------------------------
|
||
def draw_class=(draw_class)
|
||
return if @draw_class == draw_class
|
||
@draw_class = draw_class
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 項目の描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_item(index)
|
||
skill = @data[index]
|
||
lv_draw = 1
|
||
if skill[1]
|
||
rect = item_rect(index)
|
||
rect.width -= 4
|
||
|
||
#設定により描画方法を変更
|
||
if command_enabled?(index) == true
|
||
draw_item_name(skill[1], rect.x, rect.y, command_enabled?(index))
|
||
else
|
||
if @actor.skill_learn?(skill[1])
|
||
draw_item_name(skill[1], rect.x, rect.y, command_enabled?(index))
|
||
else
|
||
#設定によって処理を分岐
|
||
if skill[5] == 0
|
||
draw_item_name(skill[1], rect.x, rect.y, command_enabled?(index))
|
||
else
|
||
if cheack_base_skill(skill) == 0
|
||
change_color(normal_color, command_enabled?(index))
|
||
draw_text(rect.x + 24, rect.y, 172, line_height, KURE::SkillPoint::VIEW_LOCK_SKILL_NAME)
|
||
lv_draw = 0
|
||
else
|
||
draw_item_name(skill[1], rect.x, rect.y, command_enabled?(index))
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#描画用のLv設定
|
||
view_lv = "Lv"
|
||
|
||
if KURE::SkillPoint::VIEW_SKILL_Lv_MODE == 0
|
||
view_lv += " " if skill[0] < 10
|
||
view_lv += skill[0].to_s
|
||
view_lv = "" if skill[2] == 0
|
||
end
|
||
if KURE::SkillPoint::VIEW_SKILL_Lv_MODE == 1
|
||
before = skill[0] - 1
|
||
if before < 10
|
||
view_lv += " "
|
||
view_lv += before.to_s
|
||
end
|
||
view_lv = "Not Learned" if before == 0
|
||
view_lv = "Not Learned" if skill[2] == 0
|
||
end
|
||
if KURE::SkillPoint::VIEW_SKILL_Lv_MODE == 2
|
||
view_lv = skill[3].to_s
|
||
view_lv += " P"
|
||
end
|
||
|
||
view_lv = "" if lv_draw == 0
|
||
|
||
if is_maxlv(skill) == 0
|
||
draw_text(rect.x, rect.y, contents.width, line_height, "MASTER", 2)
|
||
else
|
||
draw_text(rect.x, rect.y, contents.width, line_height, view_lv , 2)
|
||
end
|
||
else
|
||
change_color(normal_color, command_enabled?(index))
|
||
draw_text(item_rect_for_text(index), command_name(index), alignment)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 項目を描画する矩形の取得（テキスト用）
|
||
#--------------------------------------------------------------------------
|
||
def item_rect_for_text(index)
|
||
rect = item_rect(index)
|
||
rect.x += 24
|
||
rect.width -= 8
|
||
rect
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● →キーの処理
|
||
#--------------------------------------------------------------------------
|
||
#def cursor_right(wrap = false)
|
||
# return if @data[index] == nil
|
||
# if @draw_class == 0
|
||
# return if @actor.max_skillpoint(@actor.class_id) <= @actor.used_skill_points(@actor.class_id)
|
||
# else
|
||
# return if @actor.max_skillpoint(@actor.sub_class_id) <= @actor.used_skill_points(@actor.sub_class_id)
|
||
# end
|
||
#if command_enabled?(index)
|
||
# if KURE::SkillPoint::VIEW_POPUP == 1
|
||
# view_pop_up
|
||
# else
|
||
# pop_up_skill_learn
|
||
# end
|
||
# end
|
||
# end
|
||
#--------------------------------------------------------------------------
|
||
# ● ←キーの処理
|
||
#--------------------------------------------------------------------------
|
||
def cursor_left(wrap = false)
|
||
return if @data[index] == nil
|
||
|
||
if @actor.reset_skill_flag == false
|
||
return unless KURE::SkillPoint::USE_LEFT_KEY.include?(@stype_id)
|
||
end
|
||
|
||
#ツリーが存在しない時、マスター（習得）していれば許可
|
||
if @data[index][2] == 0
|
||
if is_maxlv(@data[index]) == 0
|
||
if $game_switches[14] == true#紅茶走
|
||
skill_point_back(@data[index]) #紅茶走
|
||
else #紅茶走
|
||
end#紅茶走
|
||
end
|
||
#ツリーが存在する場合
|
||
else
|
||
#Lv1はマスターしていない場合以外処理しない
|
||
return if @data[index][0] == 1 && is_maxlv(@data[index]) == 1
|
||
#コマンドの有効をチェック
|
||
if command_enabled?(index)
|
||
if $game_switches[14] == true##紅茶走
|
||
skill_point_back(@data[index]) ##紅茶走
|
||
else ##紅茶走
|
||
end##紅茶走
|
||
#コマンドが有効ではない場合
|
||
else
|
||
if is_maxlv(@data[index]) == 0
|
||
if $game_switches[14] == true#紅茶走
|
||
skill_point_back(@data[index]) #紅茶走
|
||
else #紅茶走
|
||
end#紅茶走
|
||
end
|
||
if have_need_point(@data[index]) == 0
|
||
if $game_switches[14] == true#紅茶走
|
||
skill_point_back(@data[index]) #紅茶走
|
||
else #紅茶走
|
||
end#紅茶走
|
||
end
|
||
if cheack_base_skill(@data[index]) == 0
|
||
if $game_switches[14] == true#紅茶走
|
||
skill_point_back(@data[index]) #紅茶走
|
||
else #紅茶走
|
||
end#紅茶走
|
||
end
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ヘルプテキスト更新
|
||
#--------------------------------------------------------------------------
|
||
def update_help
|
||
if item != nil
|
||
if command_enabled?(index) == true
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
else
|
||
#習得しているスキルは説明を表示
|
||
if @draw_class == 0
|
||
|
||
if @actor.skill_learn?(item)
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
else
|
||
if @data[index][5] == 0
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
else
|
||
if cheack_base_skill(@data[index]) == 0
|
||
@help_window.set_text("このスキルの詳細は分からない")
|
||
@info_window.item = nil if @info_window
|
||
else
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
end
|
||
end
|
||
end
|
||
|
||
else
|
||
|
||
if @actor.skill_learn_sub?(item)
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
else
|
||
if @data[index][5] == 0
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
else
|
||
if cheack_base_skill(@data[index]) == 0
|
||
@help_window.set_text("このスキルの詳細は分からない")
|
||
@info_window.item = nil if @info_window
|
||
else
|
||
@help_window.set_item(item)
|
||
@info_window.item = @data[index] if @info_window
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ポップアップを表示する
|
||
#--------------------------------------------------------------------------
|
||
def view_pop_up
|
||
self.deactivate
|
||
@pop_up_window.refresh if @pop_up_window
|
||
@pop_up_window.show if @pop_up_window
|
||
@decide_window.show if @decide_window
|
||
@decide_window.activate if @decide_window
|
||
@decide_window.select(1) if @decide_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル習得の処理
|
||
#--------------------------------------------------------------------------
|
||
def pop_up_skill_learn
|
||
Audio.se_play("Audio/SE/item-01", $game_system.m_v[3], 80) #紅茶走
|
||
skill_learn(@data[index])
|
||
@point = use_select_point(@data[index])
|
||
if @draw_class == 0
|
||
@actor.use_skill_point(@actor.class_id,@point)
|
||
else
|
||
@actor.use_skill_point(@actor.sub_class_id,@point)
|
||
end
|
||
@point = 0
|
||
refresh
|
||
@status_window.refresh if @status_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルポイント回収の処理
|
||
#--------------------------------------------------------------------------
|
||
def skill_point_back(skill)
|
||
@delete_list = Array.new
|
||
@double_cheack = Array.new
|
||
|
||
skill_forget(skill)
|
||
@point = use_select_point(skill) * - 1
|
||
if @draw_class == 0
|
||
@actor.use_skill_point(@actor.class_id,@point)
|
||
else
|
||
@actor.use_skill_point(@actor.sub_class_id,@point)
|
||
end
|
||
@point = 0
|
||
|
||
delete_tree_skill_roop
|
||
|
||
refresh
|
||
@status_window.refresh if @status_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ツリーのスキルのチェックと削除
|
||
#--------------------------------------------------------------------------
|
||
def delete_tree_skill_roop
|
||
while @delete_list.size != 0 do
|
||
delete_tree_skill(@delete_list[0])
|
||
@delete_list[0] = nil
|
||
@delete_list.compact!
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ツリーのスキルのチェックと削除
|
||
#--------------------------------------------------------------------------
|
||
def delete_tree_skill(skill)
|
||
#前提スキルのID配列を取得
|
||
set_base_skill(skill)
|
||
cheack_list = @based_skill_list
|
||
#前提スキルが設定されていなければ処理しない
|
||
return if cheack_list == [] or nil
|
||
|
||
#前提スキルが設定されている場合、全てのスキルについてチェックする
|
||
for i in 0..cheack_list.size - 1
|
||
#判定用スキルデータを作成
|
||
cheack_lv = 0
|
||
cheack_tree_id = 0
|
||
|
||
#習得スキルリストから同一スキルを探し出す
|
||
for j in 0..@predata.size - 1
|
||
#同一スキルが存在する場合スキルLvとツリーIDを抜きだす
|
||
if @predata[j][1].id == cheack_list[i]
|
||
cheack_lv = @predata[j][0]
|
||
cheack_tree_id = @predata[j][2]
|
||
#該当スキルを削除
|
||
skill_simple_delete(@predata[j],cheack_tree_id,cheack_lv)
|
||
@delete_list.push(@predata[j])
|
||
end
|
||
end
|
||
|
||
#習得スキルリストから高Lvのスキルを探し出す
|
||
for k in 0..@predata.size - 1
|
||
#同一ツリーが存在する場合スキルLvをチェックする
|
||
if @predata[k][2] == cheack_tree_id
|
||
#削除したスキルよりも高Lvであれば削除リストに追加する
|
||
if @predata[k][0] > cheack_lv
|
||
skill_simple_delete(@predata[k],cheack_tree_id,cheack_lv)
|
||
@delete_list.push(@predata[k])
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 前提とされているスキルのID配列を取得
|
||
#--------------------------------------------------------------------------
|
||
def set_base_skill(skill)
|
||
#スキルのIDを取得
|
||
cheack_skill_id = skill[1].id
|
||
|
||
#判定用配列
|
||
@based_skill_list = Array.new
|
||
|
||
#習得スキルリストの前提スキルID配列を探す
|
||
for i in 0..@predata.size - 1
|
||
#前提スキル配列が存在すれば全てのIDについてチェック
|
||
if @predata[i][4] != nil
|
||
for j in 0..@predata[i][4].size - 1
|
||
#同じスキルIDが存在すればチェック
|
||
if @predata[i][4][j] == cheack_skill_id
|
||
@based_skill_list[i] = @predata[i][1].id
|
||
end
|
||
end
|
||
end
|
||
end
|
||
@based_skill_list.compact!
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの削除処理(スキル指定削除)
|
||
#--------------------------------------------------------------------------
|
||
def skill_simple_delete(skill,tree_id,cheack_lv)
|
||
#<Mツリー>であれば習得していれば処理する
|
||
if tree_id < 0
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(skill[1])
|
||
do_skill_simple_delete(skill)
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(skill[1])
|
||
do_skill_simple_delete(skill)
|
||
end
|
||
end
|
||
else
|
||
#<Fツリー>であれば習得していれば処理する
|
||
#該当スキルのLvを取得
|
||
skill_lv = skill[0]
|
||
#該当スキルを習得していれば処理
|
||
if @draw_class == 0
|
||
|
||
if @actor.skill_learn?(skill[1])
|
||
do_skill_simple_delete(skill)
|
||
#習得スキルリストの中から同一ツリーのスキルを探す
|
||
for i in 0..@predata.size - 1
|
||
if @predata[i][2] == tree_id
|
||
#前提スキルとの間のスキルに関して削除処理を走らせる
|
||
if @predata[i][0] < skill_lv
|
||
if @predata[i][0] >=cheack_lv
|
||
do_skill_simple_delete(@predata[i])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
else
|
||
|
||
if @actor.skill_learn_sub?(skill[1])
|
||
do_skill_simple_delete(skill)
|
||
#習得スキルリストの中から同一ツリーのスキルを探す
|
||
for i in 0..@predata.size - 1
|
||
if @predata[i][2] == tree_id
|
||
#前提スキルとの間のスキルに関して削除処理を走らせる
|
||
if @predata[i][0] < skill_lv
|
||
if @predata[i][0] >=cheack_lv
|
||
do_skill_simple_delete(@predata[i])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの削除処理(実行処理)
|
||
#--------------------------------------------------------------------------
|
||
def do_skill_simple_delete(skill)
|
||
#スキルを削除
|
||
if @draw_class == 0
|
||
@actor.forget_skill(skill[1].id)
|
||
else
|
||
@actor.forget_skill_sub(skill[1].id)
|
||
end
|
||
|
||
#スキルポイント処理
|
||
unless @double_cheack.include?(skill[1].id)
|
||
@point = use_select_point(skill) * - 1
|
||
if @draw_class == 0
|
||
@actor.use_skill_point(@actor.class_id,@point)
|
||
else
|
||
@actor.use_skill_point(@actor.sub_class_id,@point)
|
||
end
|
||
@point = 0
|
||
@double_cheack.push(skill[1].id)
|
||
end
|
||
|
||
refresh
|
||
@status_window.refresh if @status_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 最大Lvのチェック
|
||
#--------------------------------------------------------------------------
|
||
def is_maxlv(skill)
|
||
#ツリーIDを取得
|
||
flag = 0
|
||
skill_tree_id = tree_id(skill)
|
||
|
||
#ツリーが無ければ、習得をチェック
|
||
if skill_tree_id == 0
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(skill[1])
|
||
return 0
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(skill[1])
|
||
return 0
|
||
end
|
||
end
|
||
end
|
||
|
||
#ツリーがある場合
|
||
for i in 0..@predata.size - 1
|
||
if skill_tree_id == tree_id(@predata[i])
|
||
if sub_tree_id(skill) == 0 or sub_tree_id(skill) == sub_tree_id(@predata[i])
|
||
if skill[0] < @predata[i][0]
|
||
flag = 1
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#習得チェック
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(skill[1])
|
||
else
|
||
flag = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(skill[1])
|
||
else
|
||
flag = 1
|
||
end
|
||
end
|
||
|
||
return flag
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 前提スキルを取得しているか(0=取得していない 1=取得している)
|
||
#--------------------------------------------------------------------------
|
||
def cheack_base_skill(skill)
|
||
return 1 if skill[4] == nil
|
||
|
||
#判定用フラグ
|
||
flag = 0
|
||
flag2 = 1
|
||
#判定するする全てのスキルについて処理する
|
||
for i in 0..skill[4].size - 1
|
||
if flag2 == 1
|
||
#判定用の為のスキルデータを作成
|
||
cheack_skill = $data_skills[skill[4][i]]
|
||
cheack_tree_id = 0
|
||
cheack_skill_lv = 0
|
||
|
||
#習得スキルリストの中から同一スキルを探す
|
||
for i in 0..@predata.size - 1
|
||
#同一スキルが存在すればツリーIDとスキルLvを取得する
|
||
if @predata[i][1] == cheack_skill
|
||
cheack_tree_id = @predata[i][2]
|
||
cheack_skill_lv = @predata[i][0]
|
||
end
|
||
end
|
||
|
||
#スキルリストの中から同一ツリーIDのスキルを探す
|
||
if cheack_tree_id != 0
|
||
for i in 0..@predata.size - 1
|
||
#ツリーIDが同じであればスキルLvを調べる
|
||
if @predata[i][2] == cheack_tree_id
|
||
#より上位のスキルを覚えていればチェックする
|
||
if @predata[i][0] > cheack_skill_lv
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#判定用スキルを覚えていればチェックする
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(cheack_skill)
|
||
flag = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(cheack_skill)
|
||
flag = 1
|
||
end
|
||
end
|
||
|
||
if flag != 1
|
||
flag2 = 0
|
||
else
|
||
flag = 0
|
||
end
|
||
end
|
||
end
|
||
return flag2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 異なるサブツリーを取得しているか(0=取得していない 1=取得している)
|
||
#--------------------------------------------------------------------------
|
||
def learn_anoter_sub_skill?(skill)
|
||
flag = 0
|
||
skill_tree_id = tree_id(skill)
|
||
skill_sub_tree_id = sub_tree_id(skill)
|
||
skill_lv = skill[0]
|
||
|
||
#全習得データから
|
||
for i in 0..@predata.size - 1
|
||
#同じツリーのスキルであればサブツリーのIDをチェック
|
||
if skill_tree_id == tree_id(@predata[i])
|
||
#サブツリーIDが設定されていない項目は判定しない
|
||
if skill_sub_tree_id == 0
|
||
elsif sub_tree_id(@predata[i]) == 0
|
||
#サブツリーが設定されていればIDが異なる時習得しているか判定
|
||
elsif sub_tree_id(@predata[i]) != skill_sub_tree_id
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
return flag
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルをリストに含めるかどうか
|
||
#--------------------------------------------------------------------------
|
||
def include?(item)
|
||
#スキルタイプが違うとリストに含めない
|
||
return false if item[1].stype_id != @stype_id
|
||
|
||
#排他スキルを取得していればリストに含めない
|
||
return false if learn_anoter_sub_skill?(item) == 1
|
||
|
||
#ツリーIDが設定されていないスキルはリストに含める
|
||
skill_tree_id = tree_id(item)
|
||
return true if skill_tree_id == 0
|
||
|
||
#覚えているスキルは最大Lvを除いて表示しない
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(item[1])
|
||
return true if is_maxlv(item) == 0
|
||
return false
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(item[1])
|
||
return true if is_maxlv(item) == 0
|
||
return false
|
||
end
|
||
end
|
||
|
||
#ツリーIDが設定されている場合
|
||
flag = 0
|
||
flag2 = 0
|
||
for i in 0..@predata.size - 1
|
||
#ツリーIDが同一のスキルがあればLvを調べる
|
||
if tree_id(@predata[i]) == skill_tree_id
|
||
#Lvが高いスキルを習得しているかチェック
|
||
if item[0] < @predata[i][0]
|
||
#スキルを覚えている場合、フラグ2をON
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(@predata[i][1])
|
||
flag2 = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(@predata[i][1])
|
||
flag2 = 1
|
||
end
|
||
end
|
||
end
|
||
#Lvが1低いスキルがあれば習得しているかチェック
|
||
if item[0] - 1 == @predata[i][0]
|
||
#スキルを覚えている場合、フラグ1をON
|
||
if @draw_class == 0
|
||
if @actor.skill_learn?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
else
|
||
if @actor.skill_learn_sub?(@predata[i][1])
|
||
flag = 1
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#実際の判定
|
||
#該当スキルよりLvが高い物を覚えていれば表示しない
|
||
if flag2 == 1
|
||
return false
|
||
end
|
||
#Lvが1つ下のスキルを習得していない場合Lv1であるかチェック
|
||
if flag == 0
|
||
if item[0] == 1
|
||
return true
|
||
else
|
||
return false
|
||
end
|
||
else
|
||
return true
|
||
end
|
||
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 取得に必要なポイントがあるか(0=無い 1=ある)
|
||
#--------------------------------------------------------------------------
|
||
def have_need_point(skill)
|
||
@point = use_select_point(skill)
|
||
if @draw_class == 0
|
||
return 0 if @actor.used_skill_points(@actor.class_id) + @point > @actor.max_skillpoint(@actor.class_id)
|
||
return 1
|
||
else
|
||
return 0 if @actor.used_skill_points(@actor.sub_class_id) + @point > @actor.max_skillpoint(@actor.sub_class_id)
|
||
return 1
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの有効状態を取得
|
||
#--------------------------------------------------------------------------
|
||
def skill_enabled?(skill)
|
||
#Lvが足りない時
|
||
return false if @actor.level < need_lv(skill)
|
||
|
||
#職業レベルが足りない時
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
return false if @actor.joblevel < need_joblv(skill)
|
||
end
|
||
|
||
#前提スキルを覚えていない時
|
||
return false if cheack_base_skill(skill) == 0
|
||
|
||
#スキルポイントが足りない時
|
||
return false if have_need_point(skill) == 0
|
||
|
||
#スキルを覚えている場合、表示は選択できない
|
||
if @draw_class == 0
|
||
return false if @actor.skill_learn?(skill[1])
|
||
return true
|
||
else
|
||
return false if @actor.skill_learn_sub?(skill[1])
|
||
return true
|
||
end
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 同一ツリーでLvが下のスキルの取得
|
||
#--------------------------------------------------------------------------
|
||
def under_Lv_skill(skill,lv)
|
||
#ツリーIDを取得する
|
||
skill_tree_id = tree_id(skill)
|
||
#Lvを取得する
|
||
skill_lv = skill[0]
|
||
|
||
#スキルリストをチェックし、Lvが一つ下のスキルを探す
|
||
for i in 0..@predata.size - 1
|
||
if tree_id(@predata[i]) == skill_tree_id
|
||
if @predata[i][0] == skill_lv - lv
|
||
if @predata[i][7] == 0 or @predata[i][7] == skill[7]
|
||
old_skill = @predata[i][1]
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
return old_skill if old_skill != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの習得処理
|
||
#--------------------------------------------------------------------------
|
||
def skill_learn(skill)
|
||
#ツリーIDを取得する
|
||
skill_tree_id = tree_id(skill)
|
||
|
||
#Lvが1つ下のスキルのIDを取得
|
||
old_skill = under_Lv_skill(skill,1)
|
||
|
||
#スキルを習得し、古いスキルを忘れる
|
||
if @draw_class == 0
|
||
@actor.learn_skill(skill[1].id)
|
||
else
|
||
@actor.learn_skill_sub(skill[1].id)
|
||
end
|
||
#スキルツリーが0の場合、削除処理は存在しない
|
||
if skill_tree_id > 0
|
||
if @draw_class == 0
|
||
@actor.forget_skill(old_skill.id) if old_skill != nil
|
||
else
|
||
@actor.forget_skill_sub(old_skill.id) if old_skill != nil
|
||
end
|
||
end
|
||
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルの削除処理(Lvチェック削除)
|
||
#--------------------------------------------------------------------------
|
||
def skill_forget(skill)
|
||
#ツリーIDを取得する
|
||
skill_tree_id = tree_id(skill)
|
||
#Lvを取得する
|
||
skill_lv = skill[0]
|
||
|
||
#スキルリストをチェックし、Lvが下のスキルを探す
|
||
for i in 0..@predata.size - 1
|
||
if tree_id(@predata[i]) == skill_tree_id
|
||
#Lvが最大かチェックする
|
||
if is_maxlv(skill) == 0
|
||
#MASTER状態であればこのスキルを忘れ、1個下を覚える
|
||
if @predata[i][0] == skill_lv - 1
|
||
#サブツリー0か同一
|
||
if @predata[i][7] == 0 or @predata[i][7] == skill[7]
|
||
new_skill = @predata[i][1]
|
||
end
|
||
end
|
||
forget_skill = skill[1]
|
||
#スキルポイントの設定とツリー削除のハッシュを生成
|
||
@point = use_select_point(skill) * - 1
|
||
@delete_list.push(skill)
|
||
@double_cheack.push(skill[1].id)
|
||
else
|
||
#MASTER状態ではない時、1個下は忘れるスキル
|
||
if @predata[i][0] == skill_lv - 1
|
||
#サブツリー0か同一
|
||
if @predata[i][7] == 0 or @predata[i][7] == skill[7]
|
||
forget_skill = @predata[i][1]
|
||
#スキルポイントの設定とツリー削除のハッシュを生成
|
||
@point = use_select_point(@predata[i]) * - 1
|
||
@delete_list.push(@predata[i])
|
||
@double_cheack.push(@predata[i][1].id)
|
||
end
|
||
end
|
||
#2個下が存在すれば覚えるスキル
|
||
if @predata[i][0] == skill_lv - 2
|
||
#サブツリー0か同一
|
||
if @predata[i][7] == 0 or @predata[i][7] == skill[7]
|
||
new_skill = @predata[i][1]
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#スキルを習得し、今のスキルを忘れる
|
||
#スキルツリーが0の場合、習得処理は存在しない
|
||
if skill_tree_id != 0
|
||
if @draw_class == 0
|
||
@actor.learn_skill(new_skill.id) if new_skill != nil
|
||
else
|
||
@actor.learn_skill_sub(new_skill.id) if new_skill != nil
|
||
end
|
||
end
|
||
|
||
if @draw_class == 0
|
||
@actor.forget_skill(forget_skill.id) if forget_skill != nil
|
||
else
|
||
@actor.forget_skill_sub(forget_skill.id) if forget_skill != nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンドリストの作成
|
||
#--------------------------------------------------------------------------
|
||
def make_command_list
|
||
#データ配列を作成
|
||
@data = Array.new
|
||
#職業習得スキルリストを作成
|
||
if @draw_class == 0
|
||
@predata = @actor ? @actor.point_skills : []
|
||
else
|
||
if @actor.sub_class_id != 0
|
||
@predata = @actor ? @actor.point_skills_sub : []
|
||
else
|
||
@predata = []
|
||
end
|
||
end
|
||
#ツリーID基準で並べ直す
|
||
@predata.sort!{ |a, b| a[2] <=> b[2] }
|
||
|
||
#表示するためのデータ配列を作成
|
||
for i in 0..@predata.size - 1
|
||
if include?(@predata[i])
|
||
@data[i] = @predata[i]
|
||
end
|
||
end
|
||
@data.compact!
|
||
|
||
if @data.size != 0
|
||
for i in 0..@data.size - 1
|
||
skill = @data[i]
|
||
#スキルの有効状態を取得
|
||
if skill_enabled?(skill)
|
||
add_command(skill[1].name , :ok ,true)
|
||
else
|
||
add_command(skill[1].name , :ok ,false)
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_SkillCommand(新規)
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_SkillCommand < Window_Command
|
||
attr_accessor :actor
|
||
attr_accessor :skill_point_window
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y, width, height)
|
||
@width = width
|
||
@height = height
|
||
super(x, y)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ高さの取得
|
||
#--------------------------------------------------------------------------
|
||
def window_height
|
||
return @height
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ幅の取得
|
||
#--------------------------------------------------------------------------
|
||
def window_width
|
||
return @width
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カーソル位置の設定
|
||
#--------------------------------------------------------------------------
|
||
def index=(index)
|
||
@index = index
|
||
update_cursor
|
||
call_update_help
|
||
|
||
return if @index < 0
|
||
@skill_point_window.stype_id = current_ext if @skill_point_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクターの設定
|
||
#--------------------------------------------------------------------------
|
||
def actor=(actor)
|
||
return if @actor == actor
|
||
@actor = actor
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 描画するクラス の設定
|
||
#--------------------------------------------------------------------------
|
||
def draw_class=(draw_class)
|
||
return if @draw_class == draw_class
|
||
@draw_class = draw_class
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 全項目の描画
|
||
#--------------------------------------------------------------------------
|
||
def draw_all_items
|
||
item_max.times {|i| draw_item(i) }
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 選択項目の拡張データを取得
|
||
#--------------------------------------------------------------------------
|
||
def current_ext
|
||
current_data ? current_data[:ext] : nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンドリストの作成
|
||
#--------------------------------------------------------------------------
|
||
def make_command_list
|
||
return unless @actor
|
||
@actor.added_skill_types.sort.each do |stype_id|
|
||
name = $data_system.skill_types[stype_id]
|
||
if KURE::SkillPoint::NOT_VIEW_SKILLTYPE.include?(stype_id)
|
||
else
|
||
add_command(name, :skill, true, stype_id)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_PopupWindow(新規)
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_PopupWindow < Window_Base
|
||
attr_accessor :skill_point_window
|
||
#--------------------------------------------------------------------------
|
||
# ● リフレッシュ
|
||
#--------------------------------------------------------------------------
|
||
def refresh
|
||
contents.clear
|
||
skill = @skill_point_window.data[@skill_point_window.index] if @skill_point_window
|
||
|
||
draw_gauge(5, 0, contents.width, 1, mp_gauge_color2,crisis_color)
|
||
draw_text(5, 0, contents.width, line_height, "Confirm?")
|
||
|
||
if @skill_point_window
|
||
draw_item_name(skill[1], 5, line_height)
|
||
|
||
#描画用のLv設定
|
||
if skill[2] != 0
|
||
lv_after = "Lv"
|
||
lv_after += " " if skill[0] < 10
|
||
lv_after += skill[0].to_s
|
||
draw_text(0, line_height * 1, contents.width, line_height, lv_after, 2)
|
||
end
|
||
|
||
draw_text(5, line_height * 2, contents.width, line_height, "JOBEXP")
|
||
draw_text(0, line_height * 2, contents.width, line_height, skill[3], 2)
|
||
end
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_DecideCommand(新規)
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_DecideCommand < Window_Command
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y, width, height)
|
||
@width = width
|
||
@height = height
|
||
super(x, y)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 桁数の取得
|
||
#--------------------------------------------------------------------------
|
||
def col_max
|
||
return 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ高さの取得
|
||
#--------------------------------------------------------------------------
|
||
def window_height
|
||
return @height
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ幅の取得
|
||
#--------------------------------------------------------------------------
|
||
def window_width
|
||
return @width
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンドリストの作成
|
||
#--------------------------------------------------------------------------
|
||
def make_command_list
|
||
add_command("習得する" , :ok ,true)
|
||
add_command("やめる" , :ok ,true)
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_SkillPoint_Class_Grade_Command(新規)
|
||
#==============================================================================
|
||
class Window_k_SkillPoint_Class_Grade_Command < Window_HorzCommand
|
||
attr_accessor :skill_point_window
|
||
attr_accessor :skill_type_window
|
||
attr_accessor :status_window
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y, width)
|
||
@window_width = width
|
||
super(x, y)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウィンドウ幅の取得
|
||
#--------------------------------------------------------------------------
|
||
def window_width
|
||
@window_width
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクターの設定
|
||
#--------------------------------------------------------------------------
|
||
def actor=(actor)
|
||
return if @actor == actor
|
||
@actor = actor
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 桁数の取得
|
||
#--------------------------------------------------------------------------
|
||
def col_max
|
||
2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カーソル位置の設定
|
||
#--------------------------------------------------------------------------
|
||
def index=(index)
|
||
@index = index
|
||
update_cursor
|
||
call_update_help
|
||
|
||
return if @index < 0
|
||
@skill_point_window.draw_class = @index if @skill_point_window
|
||
@skill_type_window.draw_class = @index if @skill_type_window
|
||
@status_window.draw_class = @index if @status_window
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンドリストの作成
|
||
#--------------------------------------------------------------------------
|
||
def make_command_list
|
||
add_command("メインクラス" , :ok ,true)
|
||
if @actor != nil
|
||
if KURE::BaseScript::USE_JOBLv == 1
|
||
if @actor.sub_class_id != 0
|
||
add_command("サブクラス" , :ok ,true)
|
||
else
|
||
add_command("サブクラス" , :ok ,false)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_k_Infomation_Window(新規)
|
||
#==============================================================================
|
||
class Window_k_Infomation_Window < Window_Base
|
||
attr_accessor :skill_point_window
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(x, y,width,height)
|
||
super(x, y, width, height)
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アイテムの設定
|
||
#--------------------------------------------------------------------------
|
||
def item=(item)
|
||
return if @item == item
|
||
@item = item
|
||
refresh
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● リフレッシュ
|
||
#--------------------------------------------------------------------------
|
||
def refresh
|
||
contents.clear
|
||
change_color(system_color)
|
||
draw_text(0, 0, (contents.width / 5) - 5, line_height, "Cost " + KURE::SkillPoint::Skill_Point_NAME + ":")
|
||
draw_text(contents.width / 5, 0, (contents.width / 5) - 5, line_height, "SP Cost:")
|
||
# Koucha hashiri draw_text(contents.width / 5 * 2, 0, (contents.width / 5) - 5, line_height, "TP Cost:")
|
||
# Koucha hashiri draw_text(contents.width / 5 * 3, 0, contents.width / 5 * 1.7, line_height, "Attack Attribute:")
|
||
|
||
return unless @item
|
||
change_color(normal_color)
|
||
draw_text(0, 0, (contents.width / 5) - 5, line_height, @item[3].to_s, 2)
|
||
draw_text(contents.width / 5, 0, (contents.width / 5) - 5, line_height, @item[1].mp_cost.to_s, 2)
|
||
# Koucha hashiri draw_text(contents.width / 5 * 2, 0, (contents.width / 5) - 5, line_height, @item[1].tp_cost.to_s, 2)
|
||
|
||
str4 = $data_system.elements[@item[1].damage.element_id]
|
||
str4 = "None" if @item[1].damage.element_id == 0
|
||
str4 = "Weapon Dependent" if @item[1].damage.element_id == -1
|
||
# Koucha hashiri draw_text(contents.width / 5 * 3, 0, contents.width / 5 * 1.7, line_height, str4, 2)
|
||
end
|
||
end |