#==============================================================================
# 経験値消費でスキル習得 + スキルレベル ver1.32
#------------------------------------------------------------------------------
#[特徴]
# 「経験値消費でスキル習得」にスキルレベルを追加します。
#
#[スキル設定方法]
# スキルのメモ欄に <必要スキル:スキルID,スキルLv> と書くと、
# スキルID のスキルが スキルLv 以上でないと覚えることができません。
# 複数書くと、そのすべてを満たす必要があります。
# スキルLvの表記は省略可能で、省略した場合、レベル1 として考えます。
#
#[スキルの詳細設定]
# 下記の設定項目内のスキル詳細設定において
# HP消費、アイテム消費の設定が可能ですが、
# 「スキルコスト追加」のスクリプトが別途必要になります。
#
#[仕様変更]
# HIDE_LEARN_SKILL（習得したスキルは表示しない）の設定が、
# 『最大レベルまで上げたスキル』は表示しないの設定になります。
#
# SKILL_LEARN（習得したスキルの表示方法）の設定が、
# 最大レベルまで上げたときに表示されるようになります。
#
# ※ 必要経験値をアクター毎に設定することができなくなりました。※
#
#[スキルレベルの変更]
# イベントコマンドのスクリプトで、
# change_skill_level(アクターID, スキルID, スキルレベル)
# そのスキルを習得していなくても、設定したスキルレベルで習得します。
#
#[スキルレベルの取得]
# イベントコマンドのスクリプトで
# get_skill_level(アクターID, スキルID)
#
#[スクリプトの並び順]
# スキルコスト追加（導入している場合）
# 経験値消費でスキル習得（必須）
# スキルポイントでスキル習得（導入している場合）
# 経験値消費でスキル習得 + スキルレベル（本スクリプト）
#
# 作成：ぶちょー
# ホム：http://nyannyannyan.bake-neko.net/
# 著作：自分で作ったとか言わないで＞＜
#       改造はご自由にどうぞ。
#       リードミーとかに私の名前の載せたりするのは任意で。
#==============================================================================

#==============================================================================
# バージョンアップ情報
# ver1.32 習得済みのスキルを表示する設定にしていた場合（HIDE_LEARN_SKILL = false）
#         レベルを最大まで上げたスキルにエラーが出ていたのを修正
#         能力強化/弱体を複数記述しても１つしか効果が出ていなかったのを修正、また
#         記述方法が変わりました。
# ver1.31 指定したアクターのそのスキルのレベルを取得するコマンドを追加
# ver1.30 戦闘中、スキルの説明欄が正しく表示されないのを修正
# ver1.29 職業を変更した際、スキルレベルが１になってしまうことがあるのを修正
# ver1.28 コモンイベントが起動しないバグを修正
# ver1.27 レベルが下がっても習得できるの設定が反映されていないのを修正
# ver1.26 特定の条件で発生するバグを修正
# ver1.25 一部のパラメータが最高レベルのものが参照されていたバグを修正
# ver1.24 特定の条件で発生するバグを修正
# ver1.23 名前が正しく反映されないバグを修正
#         必要経験値の設定が正しく反映されないバグを修正
#         パッシブを設定したスキルを習得していると戦闘中エラーが出るのを修正
# ver1.22 説明文が正しく反映されないバグを修正
# ver1.21 名前が正しく反映されないバグを修正
# ver1.20 武器/防具/ステートで設定できる能力値の変化を
#         スキルでも設定できる機能を追加（いわゆるパッシブスキルの効果）
#         習得スキル名を次のレベルのものを描画するように修正
#         細かな不具合を修正
# ver1.15 最大スキルレベルが正しく反映されないバグを修正
# ver1.14 必要経験値増加率が正しく計算されないバグを修正
# ver1.13 「スキルコスト追加」と連携
# ver1.12 習得条件を満たしていないスキルを選択した際、
#         必要なスキルを表示する機能を追加
# ver1.11 スキルのメモ欄に記入した必要経験値が反映されないバグを修正
# ver1.10 詳細設定の方法を変更。より詳細に設定できるように
# ver1.00 公開
#==============================================================================

#==============================================================================
# 設定項目
#==============================================================================
module Kazari
module LearnSkill
  # ダメージ増加率
  # １レベル上げたときのダメージの増加率
  # ダメージ = ダメージ * (1 + DAMAGE_RATE * (スキルレベル-1))
  DAMAGE_RATE = 0.1 # レベル１１でダメージが２倍になる計算
  # スキルのメモ欄に <ダメージ増加率:数値> と書くと、個別に設定できます。
  
  # 消費HP増加率
  # １レベル上げたときの消費HPの増加率
  # 消費HP = 消費HP * (1 + HP_RATE * (スキルレベル-1))
  HP_RATE = 0.1 # レベル１１で消費MPが２倍になる計算
  # スキルのメモ欄に <消費HP増加率:数値> と書くと、個別に設定できます。
  
  # 消費MP増加率
  # １レベル上げたときの消費MPの増加率
  # 消費MP = 消費MP * (1 + MP_RATE * (スキルレベル-1))
  MP_RATE = 0.1 # レベル１１で消費MPが２倍になる計算
  # スキルのメモ欄に <消費MP増加率:数値> と書くと、個別に設定できます。
  
  # 消費TP増加率
  # １レベル上げたときの消費TPの増加率
  # 消費TP = 消費TP * (1 + TP_RATE * (スキルレベル-1))
  TP_RATE = 0.1 # レベル１１で消費MPが２倍になる計算
  # スキルのメモ欄に <消費TP増加率:数値> と書くと、個別に設定できます。
  
  # 必要経験値増加率
  # １レベル上げたときの必要経験値の増加率
  # 必要経験値 = 必要経験値 * (1 + EXP_RATE * スキルレベル)
  EXP_RATE = 1 # 初期値が100のとき、200,300,400,,と増える計算
  # スキルのメモ欄に <必要経験値増加率:数値> と書くと、個別に設定できます。
  
  # スキルの最大レベル
  # デフォルトの設定。
  MAX_SKILL_LEVEL = 10
  # スキルのメモ欄に <最大スキルレベル:数値> と書くと、個別に設定できます。
  
  # 最大レベルが 1 のスキルにレベルを表示しないなら true
  LEVEL_ONE = true

  # スキル名の描画方法
  SKILL_NAME = "%s Lv %d" # %s にスキル名。%d にレベル

  # スキルの詳細設定
  # 詳細設定しなかったスキルは上記で設定した増加率を元に計算します。
  SKILL = {
    137 => [{:effects => {:common_event => 1 }}],
    1000 => [{:damage_rate  => 1.0,  # ダメージ倍率
              :hp_cost      => 0,    # 消費HP
              :hp_cost_rate => false,# 最大HP割合消費
              :mp_cost      => 1,    # 消費MP
              :mp_cost_rate => false,# 最大MP割合消費
              :tp_cost      => 0,    # 消費TP
              :item_cost    => [1,1],# 消費アイテム
              :need_exp     => 100,  # 必要経験値
              :scope        => 1,    # 効果範囲
                                     # 0 : なし
                                     # 1,2 : 敵単体or全体
                                     # 3,4,5,6 : 敵ランダム１〜４体
                                     # 7,8 : 味方単体or全体
                                     # 9,10 : 味方単体or全体（戦闘不能）
                                     # 11 : 使用者
              :speed        => 10,   # 速度補正
              :success      => 100,  # 成功率
              :repeat       => 1,    # 連続回数
              :tp_gain      => 5,    # 得 TP
              :animation_id => 100,  # アニメーション ID
              
              :name         => "スキル名",
              :icon_index   => 100,  # アイコン番号
              :description  => "説明。改行は\r\nです。\\C[1]文字の色変え\\I[100]アイコン",
              :message1     => "使用時メッセージ",
              :message2     => "使用時メッセージ（２行目）",
              
              # ダメージ (RPG::UsableItem::Damage)
              :damage => {:type       => 1,     # ダメージタイプ
                                                # 0 : なし
                                                # 1,2 : HPorMPダメージ
                                                # 3,4 : HPorMP回復
                                                # 5,6 : HPorMP吸収
                          :element_id => 3,     # 属性ID
                          :formula    => 'a.atk * 4 - b.def * 2', # 計算式
                          :variance   => 20,    # 分散度
                          :critical   => true,  # クリティカル
              }, # ここまでダメージの設定
              
              # 使用効果（RPG::UsableItem::Effect）
              :effects => {:recover_hp    => [1, 10], # HP回復 [1%, 10p]
                           :recover_mp    => [0, 10], # MP回復 [0%, 10p]
                           :gain_tp       => 5,       # TP増加
                           # ステート付加 (ID1:1%, ID2:10%, ID3:100%)
                           :add_state     => {1=>0.01, 2=>0.1, 3=>1.0},
                           # ステート解除（ID3:100%）
                           :remove_state  => {3=>1.0},
                           # 能力強化（最大HP:5ターン, 攻撃力×2:3ターン）
                           :add_buff      => {0=>5, 2=>[3,3]},
                           # 能力弱体（最大MP:4ターン）
                           :add_debuff    => {1=>4},
                           # 能力強化の解除（防御力、魔法力）
                           :remove_buff   => [3, 4],
                           # 能力弱体の解除（魔法防御）
                           :remove_debuff => [5],
                           # 特殊効果（逃走）
                           :special       => [0],
                           # 成長（最大HP+3、最大MP+10）
                           :grow          => {0=>3, 1=>10},
                           # スキル習得（ID100のスキル習得）
                           :learn_skill   => [100],
                           # コモンイベント（ID1のコモンイベント実行）
                           :common_event  => 1,
              }, # ここまで使用効果の設定
              
              # 耐性
              :element_rate => {     # 属性有効度
                        1 => 1.0,    # 属性ID => 有効度
                        2 => 0.5,
              },
              :debuff_rate  => {     # 弱体有効度
                        0 => 1.0,    # 0：最大HP
                        1 => 0.5,    # 1：最大MP
                                     # 2：攻撃力, 3：防御力,…
              },
              :state_rate   => {     # ステート有効度
                        1  => 1.0,   # ステートID => 有効度
                        2  => 0.5,
              },
              :state_resist => [3,4],# ステート無効化
              # 能力値
              # 通常能力値の変化率（乗算）
              :params => { :mhp_rate => 1.0, # 最大HP
                           :mmp_rate => 1.0, # 最大MP
                           :atk_rate => 1.0, # 攻撃力
                           :def_rate => 1.0, # 防御力
                           :mat_rate => 1.0, # 魔法力
                           :mdf_rate => 1.0, # 魔法防御
                           :agi_rate => 1.0, # 敏捷性
                           :luk_rate => 1.0, # 運
              },
              # 追加能力値の変化量（加算）
              :xparams => { :hit => 0.1, # 命中率 (10%増加)
                            :eva => 0.0, # 回避率
                            :cri => 0.0, # 会心率
                            :cev => 0.0, # 会心回避率
                            :mev => 0.0, # 魔法回避率
                            :mrf => 0.0, # 魔法反射率
                            :cnt => 0.0, # 反撃率
                            :hrg => 0.0, # HP再生率
                            :mrg => 0.0, # MP再生率
                            :trg => 0.0, # TP再生率
              },
              # 特殊能力値の変化率（乗算）
              :sparams => { :trg => 1.0, # 狙われ率
                            :grd => 1.0, # 防御効果率
                            :rec => 1.0, # 回復効果率
                            :pha => 1.0, # 薬の知識
                            :mcr => 1.0, # MP消費率
                            :tcr => 1.0, # TPチャージ率
                            :pdr => 1.0, # 物理ダメージ率
                            :mdr => 1.0, # 魔法ダメージ率
                            :fdr => 1.0, # 床ダメージ率
                            :exr => 1.0, # 経験獲得率
              },
              # 攻撃
              :atk_elements => [1,2],# 攻撃時属性
              :atk_states => {       # 攻撃時ステート
                           1 => 0.1, # ステートID => 発動率
                           2 => 0.5,
              },
              :atk_speed     => 0,    # 攻撃速度補正
              :atk_times     => 1.0,  # 攻撃追加回数
              # スキル
              :stype_add     => [1],  # スキルタイプ追加
              :stype_seal    => [2],  # スキルタイプ封印
              :skill_add     => [3,4],# スキル追加
              :skill_seal    => [5],  # スキル封印
              # 装備
              :equip_wtype   => [1],  # 武器タイプ装備
              :equip_atype   => [1],  # 防具タイプ装備
              :equip_fix     => [],   # 装備固定
              :equip_seal    => [],   # 装備封印
              :slot_type     => [1],  # スロットタイプ(二刀流)
              # その他
              :action_plus   => 1.0,  # 行動回数追加
              :special_flag  => [0],  # 特殊フラグ
                                      # 0：自動戦闘
                                      # 1：防御
                                      # 2：身代わり
                                      # 3：TP持ち越し
              :collapse_type => 0,    # 消滅エフェクト
                                      # 0：通常
                                      # 1：ボス
                                      # 2：瞬間
                                      # 3：消えない
              :party_ability => [],   # パーティ能力
                                      # 0：エンカウント半減
                                      # 1：エンカウント無効
                                      # 2：不意打ち無効
                                      # 3：先制攻撃率アップ
                                      # 4：獲得金額二倍
                                      # 5：アイテム入手率二倍
             }, # ここまでがレベル1の設定
             {:damage_rate => 1.1, :mp_cost => 2, :need_exp => 200}, # レベル2
                                # 省略した項目は一つ前のレベルと同等
    ], # ここまでID1000のスキルの設定
       # レベル2まで設定したので、最大レベルは2
    
    1001 => [{:damage_rate => 1.0, :mp_cost => 1, :success => 90}, # レベル1
             # レベル1で省略した項目はデータベースと同等
             {:damage_rate => 1.1, :mp_cost => 2, :success => 95}, # レベル2
             {:damage_rate => 1.2, :mp_cost => 3}, # レベル3
             # レベル3の成功率は95%
    ], # ここまでID1001のスキルの設定
       # レベル3まで設定したので、最大レベルは3
  }
end
end
#==============================================================================
# ここまで
#==============================================================================

$kzr_imported = {} if $kzr_imported == nil
$kzr_imported["LearnSkillPlusSkillLevel"] = true
#==============================================================================
# ■ Window_LearnSkill
#==============================================================================
class Window_LearnSkill < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 項目の描画
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    skill = @data[index]
    if skill != nil
      rect.width -= 4
      draw_skill_name(skill, rect.x, rect.y)
      if @actor.skill_level_max?(skill) && !HIDE_LEARN_SKILL
        text = sprintf(SKILL_LEARN, @actor.need_exp(skill))
      elsif !@actor.need_skill?(skill) && !HIDE_UNNEED_SKILL
        text = sprintf(UNNEED_SKILL, @actor.need_exp(skill))
      else
        text = sprintf(NEED_EXP, @actor.need_exp(skill))
      end
      draw_text(rect, text, 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● スキル名の描画
  #--------------------------------------------------------------------------
  def draw_skill_name(skill, x, y)
    $game_temp.skill_level = @actor.skill_level[skill.id]
    $game_temp.skill_level += 1 unless @actor.skill_level_max?(skill)
    draw_icon(skill.icon_index, x, y)
    if @actor.skill_level_max?(skill)
      color = COLOR3
    elsif @actor.skill_can_learn?(skill)
      color = COLOR1
    else
      color = COLOR2
    end
    change_color(color)
    width = contents.width - (x + 24)
    $game_temp.skill_level = @actor.skill_level[skill.id]
    $game_temp.skill_level += 1 unless @actor.skill_level_max?(skill)
    draw_text(x + 24, y, width, line_height, skill.name)
  end
end

#==============================================================================
# ■ Window_SkillList
#==============================================================================
class Window_SkillList < Window_Selectable
  include Kazari::LearnSkill
  #--------------------------------------------------------------------------
  # ● スキル名の描画
  #--------------------------------------------------------------------------
  def draw_item_name(skill, x, y, enabled)
    $game_temp.skill_level = @actor.skill_level[skill.id] if skill != nil
    super(skill, x, y, enabled, contents.width - (x + 24))
  end
end

#==============================================================================
# ■ Window_CheckNeed
#==============================================================================
class Window_CheckNeed < Window_Selectable
  include Kazari::LearnSkill
  #--------------------------------------------------------------------------
  # ● スキルのセット
  #--------------------------------------------------------------------------
  def set_skill(skill)
    needs = skill.need_skills
    self.height = fitting_height(needs.size + 1)
    create_contents
    update_placement
    change_color(system_color)
    draw_text(0, 0, 256, line_height, "必要スキル")
    change_color(normal_color)
    needs.each_with_index do |need, i|
      draw_item_name(need, 0, line_height * (i + 1))
    end
  end
  #--------------------------------------------------------------------------
  # ● スキル名の描画
  #--------------------------------------------------------------------------
  def draw_item_name(need, x, y)
    skill = $data_skills[need[0]]
    if skill != nil
      $game_temp.skill_level = need[1]
      draw_icon(skill.icon_index, x, y)
      change_color(normal_color)
      width = contents.width - (x + 24)
      draw_text(x + 24, y, width, line_height, skill.name)
    end
  end
end

#==============================================================================
# ■ Window_SkillLevelHelp
#==============================================================================
class Window_SkillLevelHelp < Window_Help
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :actor
  #--------------------------------------------------------------------------
  # ● アイテム設定
  #--------------------------------------------------------------------------
  def set_item(item)
    $game_temp.skill_level = @actor.skill_level[item.id] if item
    super(item)
  end
end

#==============================================================================
# ■ Window_SkillLearnHelp
#==============================================================================
class Window_SkillLearnHelp < Window_Help
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :actor
  #--------------------------------------------------------------------------
  # ● アイテム設定
  #--------------------------------------------------------------------------
  def set_item(item)
    $game_temp.skill_level = @actor.skill_level[item.id] + 1 if item
    super(item)
  end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● ヘルプウィンドウの作成
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_SkillLevelHelp.new
    @help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● アクターコマンド選択の開始
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_start_actor_command_selection start_actor_command_selection
  def start_actor_command_selection
    kzr_learn_skill_by_exp_plus_level_start_actor_command_selection
    @help_window.actor = BattleManager.actor
  end
end

#==============================================================================
# ■ Scene_Skill
#==============================================================================
class Scene_Skill < Scene_ItemBase
  #--------------------------------------------------------------------------
  # ● ヘルプウィンドウの作成
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_SkillLevelHelp.new
    @help_window.actor = @actor
    @help_window.viewport = @viewport
  end
  #--------------------------------------------------------------------------
  # ● アクターの切り替え
  #--------------------------------------------------------------------------
  alias kzr_skill_learn_by_exp_plus_skill_level_on_actor_change on_actor_change
  def on_actor_change
    @help_window.actor = @actor
    kzr_skill_learn_by_exp_plus_skill_level_on_actor_change
  end
end

#==============================================================================
# ■ Scene_LearnSkill
#==============================================================================
class Scene_LearnSkill < Scene_ItemBase
  #--------------------------------------------------------------------------
  # ● ヘルプウィンドウの作成
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_SkillLearnHelp.new
    @help_window.actor = @actor
    @help_window.viewport = @viewport
  end
  #--------------------------------------------------------------------------
  # ● アクターの切り替え
  #--------------------------------------------------------------------------
  alias kzr_skill_learn_by_exp_plus_skill_level_on_actor_change on_actor_change
  def on_actor_change
    @help_window.actor = @actor
    kzr_skill_learn_by_exp_plus_skill_level_on_actor_change
  end
end

#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :skill_level
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_initialize initialize
  def initialize
    kzr_learn_skill_by_exp_plus_level_initialize
    @skill_level = 0
  end
end

#==============================================================================
# ■ Game_Action
#==============================================================================
class Game_Action
  #--------------------------------------------------------------------------
  # ● 行動速度の計算
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_speed speed
  def speed
    if subject.actor? && item.is_a?(RPG::Skill)
      $game_temp.skill_level = subject.skill_level[item.id]
    else
      $game_temp.skill_level = 0
    end
    kzr_learn_skill_by_exp_plus_level_speed
  end
end

#==============================================================================
# ■ Game_BattlerBase
#==============================================================================
class Game_BattlerBase
  #--------------------------------------------------------------------------
  # ● スキルの使用可能条件チェック
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_skill_met skill_conditions_met?
  def skill_conditions_met?(skill)
    $game_temp.skill_level = self.actor? ? self.skill_level[skill.id] : 0
    kzr_learn_skill_by_exp_plus_level_skill_met(skill)
  end
end

#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler
  include Kazari::LearnSkill
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの属性修正値を取得
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_item_element_rate item_element_rate
  def item_element_rate(user, item)
    rate = kzr_learn_skill_by_exp_plus_level_item_element_rate(user, item)
    if user.actor? && item.is_a?(RPG::Skill)
      $game_temp.skill_level = user.skill_level[item.id]
      rate *= item.damage_rate
    end
    return rate
  end
end

#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  include Kazari::LearnSkill
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader :skill_level
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_setup setup
  def setup(actor_id)
    @skill_level = [0] * $data_skills.size
    kzr_learn_skill_by_exp_plus_level_setup(actor_id)
  end
  #--------------------------------------------------------------------------
  # ● 必要経験値の計算
  #--------------------------------------------------------------------------
  def need_exp(skill)
    $game_temp.skill_level = @skill_level[skill.id]
    return skill.need_exp
  end
  #--------------------------------------------------------------------------
  # ● 習得可能なスキルオブジェクトの配列取得
  #--------------------------------------------------------------------------
  def learnable_skills
    list  = ACTOR_LEARN[@actor_id] if ACTOR_LEARN[@actor_id]
    list += CLASS_LEARN[@class_id] if CLASS_LEARN[@class_id]
    list += @added_learn_skill
    list += @skills
    if HIDE_LEARN_SKILL
      list -= @skills.select { |s_id| skill_level_max?($data_skills[s_id])}
    end
    if HIDE_UNNEED_SKILL
      list -= list.select { |s_id| !need_skill?($data_skills[s_id]) }
    end
    list.uniq.sort.collect {|id| $data_skills[id] }
  end
  #--------------------------------------------------------------------------
  # ● スキルの習得可能判定
  #--------------------------------------------------------------------------
  def skill_can_learn?(skill)
    return false if skill == nil
    return false if skill_level_max?(skill)
    return false unless need_skill?(skill)
    if $kzr_imported["LearnSkillSp"]
      return @skill_point >= need_exp(skill)
    else
      usable_exp = LEARN_FLAG ? exp : exp - current_level_exp
      return usable_exp >= need_exp(skill)
    end
  end
  #--------------------------------------------------------------------------
  # ● スキルのレベルが最大かどうかの判定
  #--------------------------------------------------------------------------
  def skill_level_max?(skill)
    skill.max_level == @skill_level[skill.id]
  end
  #--------------------------------------------------------------------------
  # ● 習得に必要なスキルを満たしているか
  #--------------------------------------------------------------------------
  def need_skill?(skill)
    skill.need_skills.each { |skill_data|
    return false if @skill_level[skill_data[0]] < skill_data[1]
    }
    return true
  end
  #--------------------------------------------------------------------------
  # ● スキルを覚える
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_learn_skill learn_skill
  def learn_skill(skill_id)
    kzr_learn_skill_by_exp_plus_level_learn_skill(skill_id)
    @skill_level[skill_id] = 1 if @skill_level[skill_id] == 0
  end
  #--------------------------------------------------------------------------
  # ● スキルの習得（経験値消費）
  #--------------------------------------------------------------------------
  def learning_skill(skill)
    if $kzr_imported["LearnSkillSp"]
      @skill_point -= need_exp(skill)
    else
      change_exp(self.exp - need_exp(skill), false)
    end
    @skill_level[skill.id] += 1
    learn_skill(skill.id) if @skill_level[skill.id] == 1
  end
  #--------------------------------------------------------------------------
  # ● スキルの消費 HP 計算
  #--------------------------------------------------------------------------
  def skill_hp_cost(skill)
    $game_temp.skill_level = @skill_level[skill.id]
    super(skill)
  end
  #--------------------------------------------------------------------------
  # ● スキルの消費 MP 計算
  #--------------------------------------------------------------------------
  def skill_mp_cost(skill)
    $game_temp.skill_level = @skill_level[skill.id]
    super(skill)
  end
  #--------------------------------------------------------------------------
  # ● スキルの消費 TP 計算
  #--------------------------------------------------------------------------
  def skill_tp_cost(skill)
    $game_temp.skill_level = @skill_level[skill.id]
    super(skill)
  end
  #--------------------------------------------------------------------------
  # ● スキルの消費 アイテム 計算
  #--------------------------------------------------------------------------
  if $kzr_imported["AddSkillCost"]
  alias kzr_learn_skill_by_exp_plus_level_skill_item_cost skill_item_cost
  def skill_item_cost(skill)
    $game_temp.skill_level = @skill_level[skill.id]
    kzr_learn_skill_by_exp_plus_level_skill_item_cost(skill)
  end
  end
  #--------------------------------------------------------------------------
  # ● スキルレベルを変更する
  #--------------------------------------------------------------------------
  def change_skill_level(skill_id, level)
    @skill_level[skill_id] = [$data_skills[skill_id].max_level, level].min
  end
  #--------------------------------------------------------------------------
  # ● 通常能力値の変化率取得
  #--------------------------------------------------------------------------
  def param_rate(param_id)
    skills.inject(super) {|r, s| r *= s.param_rate(@skill_level[s.id], param_id) }
  end
  #--------------------------------------------------------------------------
  # ● 追加能力値の取得
  #--------------------------------------------------------------------------
  def xparam(xparam_id)
    skills.inject(super) {|r, s| r += s.xparam(@skill_level[s.id], xparam_id) }
  end
  #--------------------------------------------------------------------------
  # ● 特殊能力値の取得
  #--------------------------------------------------------------------------
  def sparam(sparam_id)
    skills.inject(super) {|r, s| r *= s.sparam(@skill_level[s.id], sparam_id) }
  end
  #--------------------------------------------------------------------------
  # ● 属性有効度の取得
  #--------------------------------------------------------------------------
  def element_rate(element_id)
    skills.inject(super) {|r, s| r *= s.element_rate(@skill_level[s.id], element_id) }
  end
  #--------------------------------------------------------------------------
  # ● 弱体有効度の取得
  #--------------------------------------------------------------------------
  def debuff_rate(param_id)
    skills.inject(super) {|r, s| r *= s.debuff_rate(@skill_level[s.id], param_id) }
  end
  #--------------------------------------------------------------------------
  # ● ステート有効度の取得
  #--------------------------------------------------------------------------
  def state_rate(state_id)
    skills.inject(super) {|r, s| r *= s.state_rate(@skill_level[s.id], state_id) }
  end
  #--------------------------------------------------------------------------
  # ● 無効化するステートの配列を取得
  #--------------------------------------------------------------------------
  def state_resist_set
    skills.inject(super) {|r, s| r |= s.state_resist(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● 攻撃時属性の取得
  #--------------------------------------------------------------------------
  def atk_elements
    skills.inject(super) {|r, s| r |= s.atk_elements(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● 攻撃時ステートの取得
  #--------------------------------------------------------------------------
  def atk_states
    skills.inject(super) {|r, s| r |= s.atk_states(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● 攻撃時ステートの発動率取得
  #--------------------------------------------------------------------------
  def atk_states_rate(state_id)
    skills.inject(super) {|r, s| r += s.atk_state_rate(@skill_level[s.id], state_id) }
  end
  #--------------------------------------------------------------------------
  # ● 攻撃速度補正の取得
  #--------------------------------------------------------------------------
  def atk_speed
    skills.inject(super) {|r, s| r += s.atk_speed(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● 攻撃追加回数の取得
  #--------------------------------------------------------------------------
  def atk_times_add
    skills.inject(super) {|r, s| r += s.atk_times_add(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● 追加スキルタイプの取得
  #--------------------------------------------------------------------------
  def added_skill_types
    skills.inject(super) {|r, s| r |= s.stype_add(@skill_level[s.id]) }
  end
  #--------------------------------------------------------------------------
  # ● スキルタイプ封印の判定
  #--------------------------------------------------------------------------
  def skill_type_sealed?(stype_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.stype_seal?(@skill_level[s.id]) }.include?(stype_id)
  end
  #--------------------------------------------------------------------------
  # ● 追加スキルの取得
  #--------------------------------------------------------------------------
  def added_skills
    @skills.inject(super) {|r, id| r |= $data_skills[id].skill_add(@skill_level[id]) }
  end
  #--------------------------------------------------------------------------
  # ● スキル封印の判定
  #--------------------------------------------------------------------------
  def skill_sealed?(skill_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.skill_sealed?(@skill_level[s.id]) }.include?(skill_id)
  end
  #--------------------------------------------------------------------------
  # ● 武器装備可能の判定
  #--------------------------------------------------------------------------
  def equip_wtype_ok?(wtype_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.equip_wtype_ok?(@skill_level[s.id]) }.include?(wtype_id)
  end
  #--------------------------------------------------------------------------
  # ● 防具装備可能の判定
  #--------------------------------------------------------------------------
  def equip_atype_ok?(atype_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.equip_atype_ok?(@skill_level[s.id]) }.include?(atype_id)
  end
  #--------------------------------------------------------------------------
  # ● 装備固定の判定
  #--------------------------------------------------------------------------
  def equip_type_fixed?(etype_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.equip_type_fixed?(@skill_level[s.id]) }.include?(etype_id)
  end
  #--------------------------------------------------------------------------
  # ● 装備封印の判定
  #--------------------------------------------------------------------------
  def equip_type_sealed?(etype_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.equip_type_sealed?(@skill_level[s.id]) }.include?(etype_id)
  end
  #--------------------------------------------------------------------------
  # ● スロットタイプの取得
  #--------------------------------------------------------------------------
  def slot_type
    skills.inject([super]) {|r, s| r |= s.slot_type(@skill_level[s.id]) }.max
  end
  #--------------------------------------------------------------------------
  # ● 行動回数追加確率の配列を取得
  #--------------------------------------------------------------------------
  def action_plus_set
    skills.inject(super) {|r, s| r << s.action_plus_set(@skill_level[s.id]) } - [0.0]
  end
  #--------------------------------------------------------------------------
  # ● 消滅エフェクトの取得
  #--------------------------------------------------------------------------
  def collapse_type
    skills.inject([super]) {|r, s| r |= s.collapse_type(@skill_level[s.id]) }.max
  end
  #--------------------------------------------------------------------------
  # ● パーティ能力判定
  #--------------------------------------------------------------------------
  def party_ability(ability_id)
    return true if super
    skills.inject([]) {|r, s| r |= s.party_ability(@skill_level[s.id]) }.include?(ability_id)
  end
  #--------------------------------------------------------------------------
  # ● 自動戦闘の判定
  #--------------------------------------------------------------------------
  def auto_battle?
    return true if super
    skills.inject([]) {|r, s| r << s.auto_battle?(@skill_level[s.id]) }.include?(true) && movable?
  end
  #--------------------------------------------------------------------------
  # ● 防御の判定
  #--------------------------------------------------------------------------
  def guard?
    return true if super
    skills.inject([]) {|r, s| r << s.guard?(@skill_level[s.id]) }.include?(true) && movable?
  end
  #--------------------------------------------------------------------------
  # ● 身代わりの判定
  #--------------------------------------------------------------------------
  def substitute?
    return true if super
    skills.inject([]) {|r, s| r << s.substitute?(@skill_level[s.id]) }.include?(true) && movable?
  end
  #--------------------------------------------------------------------------
  # ● TP持ち越しの判定
  #--------------------------------------------------------------------------
  def preserve_tp?
    return true if super
    skills.inject([]) {|r, s| r << s.preserve_tp?(@skill_level[s.id]) }.include?(true)
  end
end

#==============================================================================
# ■ Game_Interpreter
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # ● スキルレベルを変更する
  #--------------------------------------------------------------------------
  def change_skill_level(actor_id, skill_id, level)
    actor = $game_actors[actor_id]
    actor.learn_skill(skill_id) unless actor.skill_learn?($data_skills[skill_id])
    actor.change_skill_level(skill_id, level)
  end
  #--------------------------------------------------------------------------
  # ● スキルレベルを取得する
  #--------------------------------------------------------------------------
  def get_skill_level(actor_id, skill_id)
    actor = $game_actors[actor_id]
    return actor.skill_level[skill_id]
  end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの使用
  #--------------------------------------------------------------------------
  alias kzr_learn_skill_by_exp_plus_level_use_item use_item
  def use_item
    item = @subject.current_action.item
    if item.is_a?(RPG::Skill)
      $game_temp.skill_level = @subject.actor? ? @subject.skill_level[item.id] : 0
    end
    kzr_learn_skill_by_exp_plus_level_use_item
  end
end

#==============================================================================
# ■ module RPG
#==============================================================================
module RPG
class Skill < UsableItem
  include Kazari::LearnSkill
  def damage_rate
    return @damage_rate_list[$game_temp.skill_level] if @damage_rate_list
    @damage_rate_list = [1.0]
    if SKILL[@id]
      @damage_rate_list += get_param(1.0, :damage_rate)
    else
      rate = DAMAGE_RATE
      rate = get_parameter("ダメージ増加率") if note.include?("ダメージ増加率")
      max_level.times {|i| @damage_rate_list << (1 + rate * i) }
    end
    @damage_rate_list[$game_temp.skill_level]
  end
  def hp_cost
    return @hp_cost_list[$game_temp.skill_level] if @hp_cost_list
    hp_cost = 0
    note.each_line {|line|
    case line
    when /<消費HP:(\d+)>/i ; hp_cost = $1.to_i
    end
    }
    @hp_cost_list = [hp_cost]
    if SKILL[@id]
      @hp_cost_list += get_param(hp_cost, :hp_cost)
    else
      rate = HP_RATE
      rate = get_parameter("消費HP増加率") if note.include?("消費HP増加率")
      max_level.times {|i| @hp_cost_list << (hp_cost * (1 + rate * i)).to_i }
    end
    @hp_cost_list[$game_temp.skill_level]
  end
  def hp_cost_rate
    return @hp_rate_list[$game_temp.skill_level] if @hp_rate_list
    hp_cost_rate = note.include?("HP割合消費")
    @hp_rate_list = [hp_cost_rate]
    if SKILL[@id]
      @hp_rate_list += get_param(hp_cost_rate, :hp_cost_rate)
    else
      @hp_rate_list += [hp_cost_rate] * max_level
    end
    @hp_rate_list[$game_temp.skill_level]
  end
  def mp_cost
    return @mp_cost_list[$game_temp.skill_level] if @mp_cost_list
    @mp_cost_list = [@mp_cost]
    if SKILL[@id]
      @mp_cost_list += get_param(@mp_cost, :mp_cost)
    else
      rate = MP_RATE
      rate = get_parameter("消費MP増加率") if note.include?("消費MP増加率")
      max_level.times {|i| @mp_cost_list << (@mp_cost * (1 + rate * i)).to_i }
    end
    @mp_cost_list[$game_temp.skill_level]
  end
  def mp_cost_rate
    return @mp_rate_list[$game_temp.skill_level] if @mp_rate_list
    mp_cost_rate = note.include?("MP割合消費")
    @mp_rate_list = [mp_cost_rate]
    if SKILL[@id]
      @mp_rate_list += get_param(mp_cost_rate, :mp_cost_rate)
    else
      @mp_rate_list += [mp_cost_rate] * max_level
    end
    @mp_rate_list[$game_temp.skill_level]
  end
  def tp_cost
    return @tp_cost_list[$game_temp.skill_level] if @tp_cost_list
    @tp_cost_list = [@tp_cost]
    if SKILL[@id]
      @tp_cost_list += get_param(@tp_cost, :tp_cost)
    else
      rate = TP_RATE
      rate = get_parameter("消費TP増加率") if note.include?("消費TP増加率")
      max_level.times {|i| @tp_cost_list << (@tp_cost * (1 + rate * i)).to_i }
    end
    @tp_cost_list[$game_temp.skill_level]
  end
  def item_cost
    return @item_cost_list[$game_temp.skill_level] if @item_cost_list
    item_cost = []
    note.each_line {|line|
    case line
    when /<消費アイテム:(\d+),(\d+)>/i ; item_cost = [$1.to_i, $2.to_i]
    end
    }
    @item_cost_list = [item_cost]
    if SKILL[@id]
      @item_cost_list += get_param(item_cost, :item_cost)
    else
      @item_cost_list += [item_cost] * max_level
    end
    @item_cost_list[$game_temp.skill_level]
  end
  def need_exp
    return @need_exp_list[$game_temp.skill_level] if @need_exp_list
    @need_exp_list = []
    if SKILL[@id]
      @need_exp_list += get_param(0, :need_exp)
    else
      need = 0
      note.each_line { |line|
      case line
      when /<必要経験値:(\d+)>/i ; need = $1.to_i
      when /<必要SP:(\d+)>/i ; need = $1.to_i
      end
      }
      @need_exp_list << need
      rate = EXP_RATE
      rate = get_parameter("必要経験値増加率") if note.include?("必要経験値増加率")
      max_level.times {|i| @need_exp_list << (need * (1 + rate * (i+1))).to_i }
    end
    @need_exp_list[$game_temp.skill_level]
  end
  def scope
    return @scope_list[$game_temp.skill_level] if @scope_list
    @scope_list = [@scope]
    if SKILL[@id]
      @scope_list += get_param(@scope, :scope)
    else
      @scope_list += [@scope] * max_level
    end
    @scope_list[$game_temp.skill_level]
  end
  def speed
    return @speed_list[$game_temp.skill_level] if @speed_list
    @speed_list = [@speed]
    if SKILL[@id]
      @speed_list += get_param(@speed, :speed)
    else
      @speed_list += [@speed] * max_level
    end
    @speed_list[$game_temp.skill_level]
  end
  def success_rate
    return @success_rate_list[$game_temp.skill_level] if @success_rate_list
    @success_rate_list = [@success_rate]
    if SKILL[@id]
      @success_rate_list += get_param(@success_rate, :success_rate)
    else
      @success_rate_list += [@success_rate] * max_level
    end
    @success_rate_list[$game_temp.skill_level]
  end
  def repeats
    return @repeats_list[$game_temp.skill_level] if @repeats_list
    @repeats_list = [@repeats]
    if SKILL[@id]
      @repeats_list += get_param(@repeats, :repeat)
    else
      @repeats_list += [@repeats] * max_level
    end
    @repeats_list[$game_temp.skill_level]
  end
  def tp_gain
    return @tp_gain_list[$game_temp.skill_level] if @tp_gain_list
    @tp_gain_list = [@tp_gain]
    if SKILL[@id]
      @tp_gain_list += get_param(@tp_gain, :tp_gain)
    else
      @tp_gain_list += [@tp_gain] * max_level
    end
    @tp_gain_list[$game_temp.skill_level]
  end
  def animation_id
    return @animation_id_list[$game_temp.skill_level] if @animation_id_list
    @animation_id_list = [@animation_id]
    if SKILL[@id]
      @animation_id_list += get_param(@animation_id, :animation_id)
    else
      @animation_id_list += [@animation_id] * max_level
    end
    @animation_id_list[$game_temp.skill_level]
  end
  def name
    return @name_list[$game_temp.skill_level] if @name_list
    @name_list = [@name]
    if SKILL[@id]
      @name_list += get_name
    else
      if max_level == 1 && LEVEL_ONE
        @name_list << @name
      else
        max_level.times {|i| @name_list << sprintf(SKILL_NAME, @name, (i + 1)) }
      end
    end
    @name_list[$game_temp.skill_level]
  end
  def icon_index
    return @icon_index_list[$game_temp.skill_level] if @icon_index_list
    @icon_index_list = [@icon_index]
    if SKILL[@id]
      @icon_index_list += get_param(@icon_index, :icon_index)
    else
      @icon_index_list += [@icon_index] * max_level
    end
    @icon_index_list[$game_temp.skill_level]
  end
  def description
    return @description_list[$game_temp.skill_level] if @description_list
    @description_list = [@description]
    if SKILL[@id]
      @description_list += get_param(@description, :description)
    else
      @description_list += [@description] * max_level
    end
    @description_list[$game_temp.skill_level]
  end
  def message1
    return @message1_list[$game_temp.skill_level] if @message1_list
    @message1_list = [@message1]
    if SKILL[@id]
      @message1_list += get_param(@message1, :message1)
    else
      @message1_list += [@message1] * max_level
    end
    @message1_list[$game_temp.skill_level]
  end
  def message2
    return @message2_list[$game_temp.skill_level] if @message2_list
    @message2_list = [@message2]
    if SKILL[@id]
      @message2_list += get_param(@message2, :message2)
    else
      @message2_list += [@message2] * max_level
    end
    @message2_list[$game_temp.skill_level]
  end
  def damage
    return @damage_list[$game_temp.skill_level] if @damage_list
    @damage_list = [@damage]
    if SKILL[@id]
      t = get_damage_param(@damage.type, :type)
      e = get_damage_param(@damage.element_id, :element_id)
      f = get_damage_param(@damage.formula, :formula)
      v = get_damage_param(@damage.variance, :variance)
      c = get_damage_param(@damage.critical, :critical)
      max_level.times do |i|
        d = UsableItem::Damage.new
        d.type = t[i]
        d.element_id = e[i]
        d.formula = f[i]
        d.variance = v[i]
        d.critical = c[i]
        @damage_list << d
      end
    else
      @damage_list += [@damage] * max_level
    end
    @damage_list[$game_temp.skill_level]
  end
  def effects
    return @effects_list[$game_temp.skill_level] if @effects_list
    @effects_list = [@effects]
    if SKILL[@id]
      rhp = get_effect_param(:recover_hp)
      rmp = get_effect_param(:recover_mp)
      gtp = get_effect_param(:gain_tp)
      ast = get_effect_param(:add_state)
      rst = get_effect_param(:remove_state)
      abu = get_effect_param(:add_buff)
      ade = get_effect_param(:add_debuff)
      rbu = get_effect_param(:remove_buff)
      rde = get_effect_param(:remove_debuff)
      spe = get_effect_param(:special)
      gro = get_effect_param(:grow)
      lsk = get_effect_param(:learn_skill)
      com = get_effect_param(:common_event)
      max_level.times do |i|
        effect = []
        effect << UsableItem::Effect.new(11, 0, rhp[i][0], rhp[i][1]) if rhp[i]
        effect << UsableItem::Effect.new(12, 0, rmp[i][0], rmp[i][1]) if rmp[i]
        effect << UsableItem::Effect.new(13, 0, gtp[i]) if gtp[i]
        effect = get_effect_values(effect, ast[i], 21) if ast[i]
        effect = get_effect_values(effect, rst[i], 22) if rst[i]
        effect = get_effect_values(effect, abu[i], 31) if abu[i]
        effect = get_effect_values(effect, ade[i], 32) if ade[i]
        effect = get_effect_values(effect, rbu[i], 33) if rbu[i]
        effect = get_effect_values(effect, rde[i], 33) if rde[i]
        effect = get_effect_values(effect, spe[i], 41) if spe[i]
        effect = get_effect_values(effect, gro[i], 42) if gro[i]
        effect = get_effect_values(effect, lsk[i], 43) if lsk[i]
        effect << UsableItem::Effect.new(44, com[i]) if com[i]
        @effects_list << effect
      end
    else
      @effects_list += [@effects] * max_level
    end
    @effects_list[$game_temp.skill_level]
  end
  def get_effect_values(effect, list, code)
    list.keys.each {|id|
      if list[id].is_a?(Array)
        list[id].each {|i| effect << UsableItem::Effect.new(code, id, i) }
      else
        effect << UsableItem::Effect.new(code, id, list[id])
      end
    }
    return effect
  end
  def param_rate(level, param_id)
    return @param_rate[level][param_id] if @param_rate
    @param_rate = [[1.0] * 8]
    if SKILL[@id]
      mhp = get_param_param(1.0, :params, :mhp_rate)
      mmp = get_param_param(1.0, :params, :mmp_rate)
      atk = get_param_param(1.0, :params, :atk_rate)
      dfe = get_param_param(1.0, :params, :def_rate)
      mat = get_param_param(1.0, :params, :mat_rate)
      mdf = get_param_param(1.0, :params, :mdf_rate)
      agi = get_param_param(1.0, :params, :agi_rate)
      luk = get_param_param(1.0, :params, :luk_rate)
      max_level.times do |i|
        rate  = [mhp[i], mmp[i], atk[i], dfe[i]]
        rate += [mat[i], mdf[i], agi[i], luk[i]]
        @param_rate << rate
      end
    else
      @param_rate += [[1.0] * 8] * max_level
    end
    @param_rate[level][param_id]
  end
  def xparam(level, param_id)
    return @xparam[level][param_id] if @xparam
    @xparam = [[0.0] * 10]
    if SKILL[@id]
      hit = get_param_param(0.0, :xparams, :hit)
      eva = get_param_param(0.0, :xparams, :eva)
      cri = get_param_param(0.0, :xparams, :cri)
      cev = get_param_param(0.0, :xparams, :cev)
      mev = get_param_param(0.0, :xparams, :mev)
      mrf = get_param_param(0.0, :xparams, :mrf)
      cnt = get_param_param(0.0, :xparams, :cnt)
      hrg = get_param_param(0.0, :xparams, :hrg)
      mrg = get_param_param(0.0, :xparams, :mrg)
      trg = get_param_param(0.0, :xparams, :trg)
      max_level.times do |i|
        rate  = [hit[i], eva[i], cri[i], cev[i], mev[i]]
        rate += [mrf[i], cnt[i], hrg[i], mrg[i], trg[i]]
        @xparam << rate
      end
    else
      @xparam += [[0.0] * 10] * max_level
    end
    @xparam[level][param_id]
  end
  def sparam(level, param_id)
    return @sparam[level][param_id] if @sparam
    @sparam = [[1.0] * 10]
    if SKILL[@id]
      trg = get_param_param(1.0, :sparams, :trg)
      grd = get_param_param(1.0, :sparams, :grd)
      rec = get_param_param(1.0, :sparams, :rec)
      pha = get_param_param(1.0, :sparams, :pha)
      mcr = get_param_param(1.0, :sparams, :mcr)
      tcr = get_param_param(1.0, :sparams, :tcr)
      pdr = get_param_param(1.0, :sparams, :pdr)
      mdr = get_param_param(1.0, :sparams, :mdr)
      fdr = get_param_param(1.0, :sparams, :fdr)
      exr = get_param_param(1.0, :sparams, :exr)
      max_level.times do |i|
        rate  = [trg[i], grd[i], rec[i], pha[i], mcr[i]]
        rate += [tcr[i], pdr[i], mdr[i], fdr[i], exr[i]]
        @sparam << rate
      end
    else
      @sparam += [[1.0] * 10] * max_level
    end
    @sparam[level][param_id]
  end
  def element_rate(level, element_id)
    return @element_rate[level][element_id] if @element_rate
    @element_rate = [[1.0] * $data_system.elements.size]
    if SKILL[@id]
      list = get_param(nil, :element_rate)
      max_level.times do |i|
        rate = @element_rate[0].clone
        list[i].keys.each {|id| rate[id] = list[i][id] } if list[i]
        @element_rate << rate
      end
    else
      @element_rate += [[1.0] * $data_system.elements.size] * max_level
    end
    @element_rate[level][element_id]
  end
  def debuff_rate(level, param_id)
    return @debuff_rate[level][param_id] if @debuff_rate
    @debuff_rate = [[1.0] * 8]
    if SKILL[@id]
      list = get_param(nil, :debuff_rate)
      max_level.times do |i|
        rate = @debuff_rate[0].clone
        list[i].keys.each {|id| rate[id] = list[i][id] } if list[i]
        @debuff_rate << rate
      end
    else
      @debuff_rate += [[1.0] * 8] * max_level
    end
    @debuff_rate[level][param_id]
  end
  def state_rate(level, state_id)
    return @state_rate[level][state_id] if @state_rate
    @state_rate = [[1.0] * $data_states.size]
    if SKILL[@id]
      list = get_param(nil, :state_rate)
      max_level.times do |i|
        rate = @state_rate[0].clone
        list[i].keys.each {|id| rate[id] = list[i][id] } if list[i]
        @state_rate << rate
      end
    else
      @state_rate += [[1.0] * $data_states.size] * max_level
    end
    @state_rate[level][state_id]
  end
  def state_resist(level)
    return @state_resist[level] if @state_resist
    @state_resist = [[]]
    if SKILL[@id]
      list = get_param([], :state_resist)
      max_level.times {|i| @state_resist << list[i] ? list[i] : [] }
    else
      @state_resist += [[]] * max_level
    end
    @state_resist[level]
  end
  def atk_elements(level)
    return @atk_elements[level] if @atk_elements
    @atk_elements = [[]]
    if SKILL[@id]
      list = get_param([], :atk_elements)
      max_level.times {|i| @atk_elements << list[i] ? list[i] : [] }
    else
      @atk_elements += [[]] * max_level
    end
    @atk_elements[level]
  end
  def atk_states(level)
    return @atk_states[level] if @atk_states
    @atk_states = [[]]
    if SKILL[@id]
      list = get_param([], :atk_states)
      max_level.times do |i|
        l = []
        list[i].keys.each {|id| l << id } unless list[i].empty?
        @atk_states << l
      end
    else
      @atk_states += [[]] * max_level
    end
    @atk_states[level]
  end
  def atk_state_rate(level, state_id)
    return @atk_state_rate[level][state_id] if @atk_state_rate
    @atk_state_rate = [[0.0] * $data_states.size]
    if SKILL[@id]
      list = get_param(nil, :atk_states)
      max_level.times do |i|
        rate = @atk_state_rate[0].clone
        list[i].keys.each {|id| rate[id] = list[i][id] } if list[i]
        @atk_state_rate << rate
      end
    else
      @atk_state_rate += [[0.0] * $data_states.size] * max_level
    end
    @atk_state_rate[level][state_id]
  end
  def atk_speed(level)
    return @atk_speed[level] if @atk_speed
    @atk_speed = [0]
    if SKILL[@id]
      @atk_speed += get_param(0, :atk_speed)
    else
      @atk_speed += [0] * max_level
    end
    @atk_speed[level]
  end
  def atk_times_add(level)
    return @atk_times_add[level] if @atk_times_add
    @atk_times_add = [0.0]
    if SKILL[@id]
      @atk_times_add += get_param(0.0, :atk_times)
    else
      @atk_times_add += [0.0] * max_level
    end
    @atk_times_add[level]
  end
  def stype_add(level)
    return @added_skill_types[level] if @added_skill_types
    @added_skill_types = [[]]
    if SKILL[@id]
      list = get_param([], :stype_add)
      max_level.times {|i| @added_skill_types << list[i] ? list[i] : [] }
    else
      @added_skill_types += [[]] * max_level
    end
    @added_skill_types[level]
  end
  def stype_seal?(level)
    return @skill_type_sealed[level] if @skill_type_sealed
    @skill_type_sealed = [[]]
    if SKILL[@id]
      list = get_param([], :stype_seal)
      max_level.times {|i| @skill_type_sealed << list[i] ? list[i] : [] }
    else
      @skill_type_sealed += [[]] * max_level
    end
    @skill_type_sealed[level]
  end
  def skill_add(level)
    return @added_skills[level] if @added_skills
    @added_skills = [[]]
    if SKILL[@id]
      list = get_param([], :skill_add)
      max_level.times {|i| @added_skills << list[i] ? list[i] : [] }
    else
      @added_skills += [[]] * max_level
    end
    @added_skills[level]
  end
  def skill_sealed?(level)
    return @skill_sealed[level] if @skill_sealed
    @skill_sealed = [[]]
    if SKILL[@id]
      list = get_param([], :skill_seal)
      max_level.times {|i| @skill_sealed << list[i] ? list[i] : [] }
    else
      @skill_sealed += [[]] * max_level
    end
    @skill_sealed[level]
  end
  def equip_wtype_ok?(level)
    return @equip_wtype_ok[level] if @equip_wtype_ok
    @equip_wtype_ok = [[]]
    if SKILL[@id]
      list = get_param([], :equip_wtype)
      max_level.times {|i| @equip_wtype_ok << list[i] ? list[i] : [] }
    else
      @equip_wtype_ok += [[]] * max_level
    end
    @equip_wtype_ok[level]
  end
  def equip_atype_ok?(level)
    return @equip_atype_ok[level] if @equip_atype_ok
    @equip_atype_ok = [[]]
    if SKILL[@id]
      list = get_param([], :equip_atype)
      max_level.times {|i| @equip_atype_ok << list[i] ? list[i] : [] }
    else
      @equip_atype_ok += [[]] * max_level
    end
    @equip_atype_ok[level]
  end
  def equip_type_fixed?(level)
    return @equip_type_fixed[level] if @equip_type_fixed
    @equip_type_fixed = [[]]
    if SKILL[@id]
      list = get_param([], :equip_fix)
      max_level.times {|i| @equip_type_fixed << list[i] ? list[i] : [] }
    else
      @equip_type_fixed += [[]] * max_level
    end
    @equip_type_fixed[level]
  end
  def equip_type_sealed?(level)
    return @equip_type_sealed[level] if @equip_type_sealed
    @equip_type_sealed = [[]]
    if SKILL[@id]
      list = get_param([], :equip_seal)
      max_level.times {|i| @equip_type_sealed << list[i] ? list[i] : [] }
    else
      @equip_type_sealed += [[]] * max_level
    end
    @equip_type_sealed[level]
  end
  def slot_type(level)
    return @slot_type[level] if @slot_type
    @slot_type = [[]]
    if SKILL[@id]
      list = get_param([], :slot_type)
      max_level.times {|i| @slot_type << list[i] ? list[i] : [] }
    else
      @slot_type += [[]] * max_level
    end
    @slot_type[level]
  end
  def action_plus_set(level)
    return @action_plus_set[level] if @action_plus_set
    @action_plus_set = [0.0]
    if SKILL[@id]
      @action_plus_set += get_param(0.0, :action_plus)
    else
      @action_plus_set += [0.0] * max_level
    end
    @action_plus_set[level]
  end
  def special_flag(level)
    return @special_flag[level] if @special_flag
    @special_flag = [[]]
    if SKILL[@id]
      list = get_param([], :special_flag)
      max_level.times {|i| @special_flag << list[i] ? list[i] : [] }
    else
      @special_flag += [[]] * max_level
    end
    @special_flag[level]
  end
  def collapse_type(level)
    return @collapse_type[level] if @collapse_type
    @collapse_type = [0]
    if SKILL[@id]
      @atk_times_add += get_param(0, :collapse_type)
    else
      @atk_times_add += [0] * max_level
    end
    @collapse_type[level]
  end
  def party_ability(level)
    return @party_ability[level] if @party_ability
    @party_ability = [[]]
    if SKILL[@id]
      list = get_param([], :party_ability)
      max_level.times {|i| @party_ability << list[i] ? list[i] : [] }
    else
      @party_ability += [[]] * max_level
    end
    @party_ability[level]
  end
  def auto_battle?(level)
    special_flag(level).include?(0)
  end
  def guard?(level)
    special_flag(level).include?(1)
  end
  def substitute?(level)
    special_flag(level).include?(2)
  end
  def preserve_tp?(level)
    special_flag(level).include?(3)
  end
  def for_opponent?
    [1, 2, 3, 4, 5, 6].include?(scope)
  end
  def for_friend?
    [7, 8, 9, 10, 11].include?(scope)
  end
  def for_dead_friend?
    [9, 10].include?(scope)
  end
  def for_user?
    scope == 11
  end
  def for_one?
    [1, 3, 7, 9, 11].include?(scope)
  end
  def for_random?
    [3, 4, 5, 6].include?(scope)
  end
  def number_of_targets
    for_random? ? scope - 2 : 0
  end
  def for_all?
    [2, 8, 10].include?(scope)
  end
  def need_selection?
    [1, 7, 9].include?(scope)
  end
  def max_level
    return @max_level if @max_level
    @max_level = MAX_SKILL_LEVEL
    note.each_line {|line|
    case line
    when /<最大スキルレベル:(\d+)>/i ; @max_level = $1.to_i
    end
    }
    @max_level = SKILL[@id].size if SKILL[@id]
    @max_level
  end
  def get_param(value, symbol)
    list = []
    max_level.times do |i|
      value = SKILL[@id][i][symbol] if SKILL[@id][i][symbol]
      list << value
    end
    list
  end
  def get_damage_param(value, symbol)
    list = []
    max_level.times do |i|
      value = SKILL[@id][i][:damage][symbol] if SKILL[@id][i][:damage] && SKILL[@id][i][:damage][symbol]
      list << value
    end
    list
  end
  def get_effect_param(symbol)
    list = []
    value = nil
    max_level.times do |i|
      value = SKILL[@id][i][:effects][symbol] if SKILL[@id][i][:effects] && SKILL[@id][i][:effects][symbol]
      list << value
    end
    list
  end
  def get_param_param(value, s1, s2)
    list = []
    max_level.times do |i|
      value = SKILL[@id][i][s1][s2] if SKILL[@id][i][s1] && SKILL[@id][i][s1][s2]
      list << value
    end
    list
  end
  def get_name
    list = []
    if max_level == 1 && LEVEL_ONE
      list << @name
    else
      set_name = false
      max_level.times do |i|
        if SKILL[@id][i][:name]
          @value = SKILL[@id][i][:name]
          set_name = true
        elsif set_name == false
          @value = sprintf(SKILL_NAME, @name, (i + 1))
        end
        list << @value
      end
    end
    list
  end
  def get_parameter(text)
    note.scan(/^<#{text}:(.+)>/im).to_s.to_f
  end
  def need_skills
    return @needs if @needs
    @needs = []
    note.each_line {|line|
    case line
    when /<必要スキル:(\d+),(\d+)>/i ; @needs << [$1.to_i, $2.to_i]
    when /<必要スキル:(\d+)>/i ; @needs << [$1.to_i, 1]
    end
    }
    @needs
  end
end
end