#◆◇◆◇◆  パラメータ追加 ver 1.40  ◇◆◇◆◇
#  サポート掲示板 http://www2.ezbbs.net/21/minto-aaa/
#   by みんと

=begin

更新履歴

ver 1.40
ステートでlukを調節できるように改良。

使い方

SSPを消費して使用するスキルを設定する場合は、
例えば
ヒール sp100の様に
スキル名 半角スペースsp消費ポイント
と設定してください。
spの後の半角数字がそのスキルの消費SSPになります。
(この場合は100ポイントになります)


また、
イベントのスクリプトで操作をしたい場合は

iterate_actor(1) do |actor| ←0で全体
  actor.ssp -= 1
end

または

actor = $game_party.actors[隊列ID] ←先頭は0
actor.ssp -= 1

といった様に記述してください
ラックの場合も同様です。

actor.luk += x

エネミーの設定

例えば、
ゴースト sp1lu10の様に、
エネミー名 半角スペースsp値lu値と設定してください。
spの後の値がエネミーのSSP、
luの後の値がエネミーのLUKになります。

ゴースト lu10sp1
ゴースト lu10

などでも可能。

SSP回復アイテム設定

例えば、
ポーション sp1sp10の様に、
アイテム名 半角スペースsp値sp値と設定してください。
左のsp値がSSP回復率、
右のsp値がSSP回復ポイントになります。
(上の例では回復率1％＆回復ポイント10になります)

上昇アイテム

同じように
ポーション us1ul2と設定してください。
usの後の値がSSP上昇ポイント、
ulの後の値がLUK上昇ポイントです。

上昇装備

例えば
ブロンズソード sp1lu2の様に
装備名 半角スペースsp値lu値と設定してください。
spの後の値が装備の上昇SSP、
luの後の値が装備の上昇LUKになります。

ステート変化

ステート名で、
例えば 毒 lu110
といったように記述してください。
100が基本で110なら10%上昇します。

記入していない場合は変化しません。

=end

#==============================================================================
# □ カスタマイズポイント
#==============================================================================

module MINTO
  
  # パラメータ追加を有効化
  MINTO::RGSS["parameter_addition"] = true
  
  # SSPの最大値
  MAX_SSP           = 999
  
  # LUKの最大値
  MAX_LUK           = 999
  
  # SSPの表示の有無( true で表示 false で非表示)
  SSP_SWITCH        = true
  
  # LUKの表示の有無( true で表示 false で非表示)
  LUK_SWITCH        = true
  
  # 追加能力の個人別表示の使用の有無( true で使用 false で不使用)
  PERSONAL_ABILITY  = false
  
  # SSPの基本値(アクターID順に記述。小数点以下でも可能)
  SSP_BASE          = [50, 50, 50, 50, 50, 50, 50, 50]
  
  # LUKの基本値(アクターID順に記述。小数点以下でも可能)
  LUK_BASE          = [10, 10, 10, 10, 10, 10, 10, 10]
  
  # SSPのLV UP上昇値(アクターID順に記述。小数点以下でも可能)
  SSP_UP            = [10, 10, 10, 10, 10, 10, 10, 10]
  
  # LUKのLV UP上昇値(アクターID順に記述。小数点以下でも可能)
  LUK_UP            = [10, 10, 10, 10, 10, 10, 10, 10]
  
  # SSPの名称
  SSP_NAME          = "SSP"
  
  # アクター別のSSPの名前(アクターID順に記述)
  # PERSONAL_ABILITY が true の場合だけ記入
  SSP_NAME2         = ["AP","SSP","SSP","SSP","TP","TP","TP","TP"]
  
  # LUKの名称
  LUK_NAME          = "幸運"
  
  # アクター別のLUKの名前(アクターID順に記述)
  # PERSONAL_ABILITY が true の場合だけ記入
  LUK_NAME2         = ["強運","幸運","幸運","幸運","運","運","運","運"]
  
end
 
if MINTO::RGSS["parameter_addition"]
#==============================================================================
# ■ RPG::Skill
#==============================================================================
module RPG
  class Skill
    def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def ssp_cost
      name = @name.split(/sp/)[1].to_i
      return name != 0 ? name : 0
    end
  end
end
#==============================================================================
# ■ RPG::Item
#==============================================================================
module RPG
  class Item
    def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def ssp_recover
      name = @name.split(/sp/)[1].to_i
      return name != 0 ? name : 0
    end
    def ssp_recover2
      name = @name.split(/sp/)[2].to_i
      return name != 0 ? name : 0
    end
    def ssp
      name = @name.split(/us/)[1].to_i
      return name != 0 ? name : 0
    end
    def luk
      name = @name.split(/ul/)[1].to_i
      return name != 0 ? name : 0
    end
  end
end
#==============================================================================
# ■ RPG::Enemy
#==============================================================================
module RPG
  class Enemy
    def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def ssp
      name = @name.split(/sp/)[1].to_i
      return name != 0 ? name : 0
    end
    def luk
      name = @name.split(/lu/)[1].to_i
      return name != 0 ? name : 0
    end
  end
end
#==============================================================================
# ■ RPG::Weapon
#==============================================================================
module RPG
  class Weapon
    def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def ssp
      name = @name.split(/sp/)[1].to_i
      return name != 0 ? name : 0
    end
    def luk
      name = @name.split(/lu/)[1].to_i
      return name != 0 ? name : 0
    end
  end
end
#==============================================================================
# ■ RPG::Armor
#==============================================================================
module RPG
  class Armor
    def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def ssp
      name = @name.split(/sp/)[1].to_i
      return name != 0 ? name : 0
    end
    def luk
      name = @name.split(/lu/)[1].to_i
      return name != 0 ? name : 0
    end
  end
end
#==============================================================================
# ■ RPG::State
#==============================================================================

module RPG
  class State
   def name
      name = @name.split(/ /)[0]
      return name != nil ? name : ''
    end
    def luk_up
      name = @name.split(/lu/)[1].to_i
      return name != 0 ? name : 100
    end
  end
end
#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader   :ssp               # SSP
  attr_reader   :luk               # LUK
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_Mint_Parameter_Addition initialize
  def initialize
    initialize_Mint_Parameter_Addition
    @ssp = 0
    @maxssp_plus = 0
    @luk = 0
    @luk_plus = 0
  end  
  #--------------------------------------------------------------------------
  # ● MaxSSP の取得
  #--------------------------------------------------------------------------
  def maxssp
    n = [[base_maxssp + @maxssp_plus, 0].max, MINTO::MAX_SSP].min
    n = [[Integer(n), 0].max, MINTO::MAX_SSP].min
    return n
  end
  #--------------------------------------------------------------------------
  # ● MaxSSP の設定
  #--------------------------------------------------------------------------
  def maxssp=(maxssp)
    @maxssp_plus += maxssp - self.maxssp
    @maxssp_plus = [[@maxssp_plus, -MINTO::MAX_SSP].max, MINTO::MAX_SSP].min
    @ssp = [@ssp, self.maxssp].min
  end
  #--------------------------------------------------------------------------
  # ● SSP の変更
  #--------------------------------------------------------------------------
  def ssp=(ssp)
    @ssp = [[ssp, maxssp].min, 0].max
  end
  #--------------------------------------------------------------------------
  # ● LUK の取得
  #--------------------------------------------------------------------------
  def luk
    n = [[base_luk + @luk_plus, 0].max, MINTO::MAX_LUK].min
    n = [[Integer(n), 0].max, MINTO::MAX_LUK].min
    @states.each do |i|
      n *= $data_states[i].luk_up / 100
    end
    return [n, MINTO::MAX_LUK].min
  end
  #--------------------------------------------------------------------------
  # ● LUK の設定
  #--------------------------------------------------------------------------
  def luk=(luk)
    @luk_plus += luk - self.luk
    @luk_plus = [[@luk_plus, -MINTO::MAX_LUK].max, MINTO::MAX_LUK].min
  end
  #--------------------------------------------------------------------------
  # ● 全回復
  #--------------------------------------------------------------------------
  alias minto_recover_all recover_all
  def recover_all
    minto_recover_all
    @ssp = maxssp
  end
end

#==============================================================================
# ■ Game_Battler 3
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● スキルの使用可能判定
  #--------------------------------------------------------------------------
  def skill_can_use?(skill_id)
    # SP が足りない場合は使用不可
    if $data_skills[skill_id].sp_cost > self.sp || 
      $data_skills[skill_id].ssp_cost > self.ssp
      return false
    end    
    # 戦闘不能の場合は使用不可
    if dead?
      return false
    end
    # 沈黙状態の場合、物理スキル以外は使用不可
    if $data_skills[skill_id].atk_f == 0 and self.restriction == 1
      return false
    end
    # 使用可能時を取得
    occasion = $data_skills[skill_id].occasion
    # 戦闘中の場合
    if $game_temp.in_battle
      # [常時] または [バトルのみ] なら使用可
      return (occasion == 0 or occasion == 1)
      # 戦闘中ではない場合
      else
      # [常時] または [メニューのみ] なら使用可
      return (occasion == 0 or occasion == 2)
    end      
  end
  #--------------------------------------------------------------------------
  # ● アイテムの効果適用
  #--------------------------------------------------------------------------
  def item_effect(item)
    # クリティカルフラグをクリア
    self.critical = false
    # アイテムの効果範囲が HP 1 以上の味方で、自分の HP が 0、
    # またはアイテムの効果範囲が HP 0 の味方で、自分の HP が 1 以上の場合
    if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
       ((item.scope == 5 or item.scope == 6) and self.hp >= 1)
      # メソッド終了
      return false
    end
    # 有効フラグをクリア
    effective = false
    # コモンイベント ID が有効の場合は有効フラグをセット
    effective |= item.common_event_id > 0
    # 命中判定
    hit_result = (rand(100) < item.hit)
    # 不確実なスキルの場合は有効フラグをセット
    effective |= item.hit < 100
    # 命中の場合
    if hit_result == true
      # 回復量を計算
      recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
      recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
      recover_ssp = maxssp * item.ssp_recover / 100 + item.ssp_recover2
      if recover_hp < 0
        recover_hp += self.pdef * item.pdef_f / 20
        recover_hp += self.mdef * item.mdef_f / 20
        recover_hp = [recover_hp, 0].min
      end
      # 属性修正
      recover_hp *= elements_correct(item.element_set)
      recover_hp /= 100
      recover_sp *= elements_correct(item.element_set)
      recover_sp /= 100
      recover_ssp *= elements_correct(item.element_set)
      recover_ssp /= 100
      # 分散
      if item.variance > 0 and recover_hp.abs > 0
        amp = [recover_hp.abs * item.variance / 100, 1].max
        recover_hp += rand(amp+1) + rand(amp+1) - amp
      end
      if item.variance > 0 and recover_sp.abs > 0
        amp = [recover_sp.abs * item.variance / 100, 1].max
        recover_sp += rand(amp+1) + rand(amp+1) - amp
      end
      if item.variance > 0 and recover_ssp.abs > 0
        amp = [recover_ssp.abs * item.variance / 100, 1].max
        recover_ssp += rand(amp+1) + rand(amp+1) - amp
      end
      # 回復量の符号が負の場合
      if recover_hp < 0
        # 防御修正
        if self.guarding?
          recover_hp /= 2
        end
      end
      # HP 回復量の符号を反転し、ダメージの値に設定
      self.damage = -recover_hp
      # HP および SP を回復
      last_hp = self.hp
      last_sp = self.sp
      last_ssp = self.ssp
      self.hp += recover_hp
      self.sp += recover_sp
      self.ssp += recover_ssp
      effective |= self.hp != last_hp
      effective |= self.sp != last_sp
      effective |= self.ssp != last_ssp
      # ステート変化
      @state_changed = false
      effective |= states_plus(item.plus_state_set)
      effective |= states_minus(item.minus_state_set)
      # 追加パラメータ上昇値が設定されている場合
      if item.ssp > 0 || item.luk > 0
        @maxssp_plus += item.ssp
        @luk_plus += item.luk        
        # 有効フラグをセット
        effective = true
      end
      # パラメータ上昇値が有効の場合
      if item.parameter_type > 0 and item.parameter_points != 0
        # パラメータで分岐
        case item.parameter_type
        when 1  # MaxHP
          @maxhp_plus += item.parameter_points
        when 2  # MaxSP
          @maxsp_plus += item.parameter_points
        when 3  # 腕力
          @str_plus += item.parameter_points
        when 4  # 器用さ
          @dex_plus += item.parameter_points
        when 5  # 素早さ
          @agi_plus += item.parameter_points
        when 6  # 魔力
          @int_plus += item.parameter_points
        end
        # 有効フラグをセット
        effective = true
      end
      # HP 回復率と回復量が 0 の場合
      if item.recover_hp_rate == 0 and item.recover_hp == 0
        # ダメージに空文字列を設定
        self.damage = ""
        # SP 回復率と回復量が 0、パラメータ上昇値が無効の場合
        if item.recover_sp_rate == 0 and item.recover_sp == 0 and
           (item.parameter_type == 0 or item.parameter_points == 0)
          # ステートに変化がない場合
          unless @state_changed
            # ダメージに "Miss" を設定
            self.damage = "Miss"
          end
        end
      end
    # ミスの場合
    else
      # ダメージに "Miss" を設定
      self.damage = "Miss"
    end
    # 戦闘中でない場合
    unless $game_temp.in_battle
      # ダメージに nil を設定
      self.damage = nil
    end
    # メソッド終了
    return effective
  end
end  
#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  alias minto_parameter_addition_setup setup
  def setup(actor_id)
    minto_parameter_addition_setup(actor_id)
    @ssp = maxssp
    @maxssp_plus = 0
    @luk = luk
    @luk_plus = 0
  end
  #--------------------------------------------------------------------------
  # ● 基本 MaxSSP の取得
  #--------------------------------------------------------------------------
  def base_maxssp
    i = @actor_id -1
    n = MINTO::SSP_BASE[i]
    n += MINTO::SSP_UP[i] * (@level - 1)
    weapon = $data_weapons[@weapon_id]
    armor1 = $data_armors[@armor1_id]
    armor2 = $data_armors[@armor2_id]
    armor3 = $data_armors[@armor3_id]
    armor4 = $data_armors[@armor4_id]    
    n += weapon != nil ? weapon.ssp : 0
    n += armor1 != nil ? armor1.ssp : 0
    n += armor2 != nil ? armor2.ssp : 0
    n += armor3 != nil ? armor3.ssp : 0
    n += armor4 != nil ? armor4.ssp : 0
    return n.floor
  end
  #--------------------------------------------------------------------------
  # ● 基本 LUK の取得
  #--------------------------------------------------------------------------
  def base_luk
    i = @actor_id -1
    n = MINTO::LUK_BASE[i]
    n += MINTO::LUK_UP[i] * (@level - 1)
    weapon = $data_weapons[@weapon_id]
    armor1 = $data_armors[@armor1_id]
    armor2 = $data_armors[@armor2_id]
    armor3 = $data_armors[@armor3_id]
    armor4 = $data_armors[@armor4_id]    
    n += weapon != nil ? weapon.luk : 0
    n += armor1 != nil ? armor1.luk : 0
    n += armor2 != nil ? armor2.luk : 0
    n += armor3 != nil ? armor3.luk : 0
    n += armor4 != nil ? armor4.luk : 0
    return n.floor
  end
end
#==============================================================================
# ■ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias minto_parameter_addition_initialize initialize
  def initialize(troop_id, member_index)
    minto_parameter_addition_initialize(troop_id, member_index)
    @ssp = maxssp
    @luk = luk
  end
  #--------------------------------------------------------------------------
  # ● 基本 MaxSSP の取得
  #--------------------------------------------------------------------------
  def base_maxssp
    enemy = $data_enemies[@enemy_id]
    n = enemy.ssp
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本 LUK の取得
  #--------------------------------------------------------------------------
  def base_luk
    enemy = $data_enemies[@enemy_id]
    n = enemy.luk
    return n
  end
end
#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ● SSP の描画
  #--------------------------------------------------------------------------
  def draw_actor_ssp(actor, x, y, width = 144, flag = true)
    # SSPの文字列を描画
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, 32, MINTO::SSP_NAME)
    if flag == true
      # MaxSSP を描画するスペースがあるか計算
      if width - 32 >= 108
        ssp_x = x + width - 108
        flag = true
      elsif width - 32 >= 48
        ssp_x = x + width - 48
        flag = false
      end
    end
    # SSP を描画
    self.contents.font.color = actor.ssp == 0 ? knockout_color :
      actor.ssp <= actor.maxssp / 4 ? crisis_color : normal_color
    self.contents.draw_text(ssp_x, y, 48, 32, actor.ssp.to_s, 2)
    # MaxSSP を描画
    if flag
      self.contents.font.color = normal_color
      self.contents.draw_text(ssp_x + 48, y, 12, 32, "/", 1)
      self.contents.draw_text(ssp_x + 60, y, 48, 32, actor.maxssp.to_s)
    end
  end
  #--------------------------------------------------------------------------
  # ● LUK の描画
  #--------------------------------------------------------------------------
  def draw_actor_luk(actor, x, y, width = 144, flag = true)
    # LUKの文字列を描画
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 120, 32, MINTO::LUK_NAME)
    if flag == true
      # LUK を描画するスペースがあるか計算
      if width - 32 >= 108
        luk_x = x + width - 108
        flag = true
      elsif width - 32 >= 48
        luk_x = x + width - 48
        flag = false
      end
    end
    # LUK を描画
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 120, y, 36, 32, actor.luk.to_s, 2)
  end  
  #--------------------------------------------------------------------------
  # ● SSP2 の描画
  #--------------------------------------------------------------------------
  def draw_actor_ssp2(actor, x, y, width = 144, flag = true)
    # SSP2の文字列を描画
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, 32, MINTO::SSP_NAME2[actor.id-1])
    if flag == true
      # MaxSSP を描画するスペースがあるか計算
      if width - 32 >= 108
        ssp_x = x + width - 108
        flag = true
      elsif width - 32 >= 48
        ssp_x = x + width - 48
        flag = false
      end
    end
    # SSP を描画
    self.contents.font.color = actor.ssp == 0 ? knockout_color :
      actor.ssp <= actor.maxssp / 4 ? crisis_color : normal_color
    self.contents.draw_text(ssp_x, y, 48, 32, actor.ssp.to_s, 2)
    # MaxSSP を描画
    if flag
      self.contents.font.color = normal_color
      self.contents.draw_text(ssp_x + 48, y, 12, 32, "/", 1)
      self.contents.draw_text(ssp_x + 60, y, 48, 32, actor.maxssp.to_s)
    end
  end  
  #--------------------------------------------------------------------------
  # ● LUK2 の描画
  #--------------------------------------------------------------------------
  def draw_actor_luk2(actor, x, y, width = 144, flag = true)
    # LUK2の文字列を描画
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 120, 32, MINTO::LUK_NAME2[actor.id-1])
    if flag == true
      # LUK を描画するスペースがあるか計算
      if width - 32 >= 108
        luk_x = x + width - 108
        flag = true
      elsif width - 32 >= 48
        luk_x = x + width - 48
        flag = false
      end
    end
    # LUK を描画
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 120, y, 36, 32, actor.luk.to_s, 2)
  end
end
#==============================================================================
# ■ Window_Status
#==============================================================================

class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_graphic(@actor, 40, 112)
    draw_actor_name(@actor, 4, 0)
    draw_actor_class(@actor, 4 + 144, 0)
    if MINTO::SSP_SWITCH
      draw_actor_level(@actor, 96, 32)
      draw_actor_state(@actor, 170, 32)
      draw_actor_hp(@actor, 96, 72, 172)
      draw_actor_sp(@actor, 96, 104, 172)
      if MINTO::PERSONAL_ABILITY
        draw_actor_ssp2(@actor, 96, 136, 172)
      else
        draw_actor_ssp(@actor, 96, 136, 172)
      end
    else
      draw_actor_level(@actor, 96, 32)
      draw_actor_state(@actor, 96, 64)
      draw_actor_hp(@actor, 96, 112, 172)
      draw_actor_sp(@actor, 96, 144, 172)
    end
    if MINTO::LUK_SWITCH
      draw_actor_parameter(@actor, 96, 170, 0)
      draw_actor_parameter(@actor, 96, 202, 1)
      draw_actor_parameter(@actor, 96, 234, 2)
      draw_actor_parameter(@actor, 96, 272, 3)
      draw_actor_parameter(@actor, 96, 304, 4)
      draw_actor_parameter(@actor, 96, 336, 5)
      draw_actor_parameter(@actor, 96, 368, 6)
      if MINTO::PERSONAL_ABILITY
        draw_actor_luk2(@actor, 96, 400)
      else
        draw_actor_luk(@actor, 96, 400)
      end
    else
      draw_actor_parameter(@actor, 96, 192, 0)
      draw_actor_parameter(@actor, 96, 224, 1)
      draw_actor_parameter(@actor, 96, 256, 2)
      draw_actor_parameter(@actor, 96, 304, 3)
      draw_actor_parameter(@actor, 96, 336, 4)
      draw_actor_parameter(@actor, 96, 368, 5)
      draw_actor_parameter(@actor, 96, 400, 6)
    end
    self.contents.font.color = system_color
    self.contents.draw_text(320, 48, 80, 32, "EXP")
    self.contents.draw_text(320, 80, 80, 32, "NEXT")
    self.contents.font.color = normal_color
    self.contents.draw_text(320 + 80, 48, 84, 32, @actor.exp_s, 2)
    self.contents.draw_text(320 + 80, 80, 84, 32, @actor.next_rest_exp_s, 2)
    self.contents.font.color = system_color
    self.contents.draw_text(320, 160, 96, 32, "装備")
    draw_item_name($data_weapons[@actor.weapon_id], 320 + 16, 208)
    draw_item_name($data_armors[@actor.armor1_id], 320 + 16, 256)
    draw_item_name($data_armors[@actor.armor2_id], 320 + 16, 304)
    draw_item_name($data_armors[@actor.armor3_id], 320 + 16, 352)
    draw_item_name($data_armors[@actor.armor4_id], 320 + 16, 400)
  end
end
#==============================================================================
# ■ Window_MenuStatus
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.actors.size
    for i in 0...$game_party.actors.size
      x = 64
      y = i * 116
      actor = $game_party.actors[i]
      draw_actor_graphic(actor, x - 40, y + 80)
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 144, y)
      draw_actor_level(actor, x, y + 32)
      draw_actor_state(actor, x + 90, y + 32)
      draw_actor_exp(actor, x, y + 64)
      if MINTO::SSP_SWITCH
        draw_actor_hp(actor, x + 236, y + 30)
        draw_actor_sp(actor, x + 236, y + 50)
        if MINTO::PERSONAL_ABILITY
          draw_actor_ssp2(actor, x + 236, y + 70)
        else
          draw_actor_ssp(actor, x + 236, y + 70)
        end
      else
        draw_actor_hp(actor, x + 236, y + 32)
        draw_actor_sp(actor, x + 236, y + 64)
      end
    end
  end
end 
#==============================================================================
# ■ Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.actors.size
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      actor_x = i * 160 + 4
      if MINTO::SSP_SWITCH
        draw_actor_name(actor, actor_x, 0)
        draw_actor_hp(actor, actor_x, 30, 120)
        draw_actor_sp(actor, actor_x, 50, 120)
        if MINTO::PERSONAL_ABILITY
          draw_actor_ssp2(actor, actor_x, 70, 120)
        else
          draw_actor_ssp(actor, actor_x, 70, 120)
        end
      else
        draw_actor_name(actor, actor_x, 0)
        draw_actor_hp(actor, actor_x, 32, 120)
        draw_actor_sp(actor, actor_x, 64, 120)
      end
      if @level_up_flags[i]
        self.contents.font.color = normal_color
        self.contents.draw_text(actor_x, 96, 120, 32, "LEVEL UP!")
      else
        draw_actor_state(actor, actor_x, 96)
      end
    end
  end
end
#==============================================================================
# ■ Window_Skill
#==============================================================================

class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 項目の描画
  #     index : 項目番号
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    actor = @actor
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end 
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.font.size = 16
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    self.contents.font.size = 15
    if skill.ssp_cost == 0 && skill.sp_cost > 0
      self.contents.draw_text(x + 180, y, 48, 32, $data_system.words.sp)
      self.contents.draw_text(x + 230, y, 48, 32, skill.sp_cost.to_s, 2)
    elsif skill.sp_cost == 0 && skill.ssp_cost > 0
      if MINTO::PERSONAL_ABILITY
        self.contents.draw_text(x + 180, y, 48, 32, MINTO::SSP_NAME2[actor.id-1])
      else
        self.contents.draw_text(x + 180, y, 48, 32, MINTO::SSP_NAME)
      end
      self.contents.draw_text(x + 230, y, 48, 32, skill.ssp_cost.to_s, 2)
    elsif skill.ssp_cost > 0 && skill.sp_cost > 0
      if MINTO::PERSONAL_ABILITY
        self.contents.draw_text(x + 180, y, 48, 32, $data_system.words.sp +
        "/" + MINTO::SSP_NAME2[actor.id-1])
      else
        self.contents.draw_text(x + 180, y, 48, 32, $data_system.words.sp +
        "/" + MINTO::SSP_NAME)
      end
      self.contents.draw_text(x + 230, y, 48, 32, skill.sp_cost.to_s + "/" +
      skill.ssp_cost.to_s, 2)
    end
  end
end
#==============================================================================
# ■ Window_SkillStatus
#==============================================================================

class Window_SkillStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    actor = @actor
    self.contents.clear
    self.contents.font.size = 17
    draw_actor_name(@actor, 4, 0)
    draw_actor_state(@actor, 110, 0)
    draw_actor_hp(@actor, 190, 0)
    draw_actor_sp(@actor, 330, 0)
    if MINTO::PERSONAL_ABILITY
      draw_actor_ssp2(@actor, 470, 0)
    else
      draw_actor_ssp(@actor, 470, 0)
    end
  end
end
#==============================================================================
# ■ Scene_Battle (分割定義 4)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● スキルアクション 結果作成
  #--------------------------------------------------------------------------
  def make_skill_action_result
    # スキルを取得
    @skill = $data_skills[@active_battler.current_action.skill_id]
    # 強制アクションでなければ
    unless @active_battler.current_action.forcing
      # SP 切れなどで使用できなくなった場合
      unless @active_battler.skill_can_use?(@skill.id)
        # アクション強制対象のバトラーをクリア
        $game_temp.forcing_battler = nil
        # ステップ 1 に移行
        @phase4_step = 1
        return
      end
    end
    # SP 消費
    @active_battler.ssp -= @skill.ssp_cost
    @active_battler.sp -= @skill.sp_cost
    # ステータスウィンドウをリフレッシュ
    @status_window.refresh
    # ヘルプウィンドウにスキル名を表示
    @help_window.set_text(@skill.name, 1)
    # アニメーション ID を設定
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # コモンイベント ID を設定
    @common_event_id = @skill.common_event_id
    # 対象側バトラーを設定
    set_target_battlers(@skill.scope)
    # スキルの効果を適用
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
  end
end
#==============================================================================
# ■ Scene_Skill
#==============================================================================

class Scene_Skill  
  #--------------------------------------------------------------------------
  # ● フレーム更新 (スキルウィンドウがアクティブの場合)
  #--------------------------------------------------------------------------
  def update_skill
    # B ボタンが押された場合
    if Input.trigger?(Input::B)
      # キャンセル SE を演奏
      $game_system.se_play($data_system.cancel_se)
      # メニュー画面に切り替え
      $scene = Scene_Menu.new(1)
      return
    end
    # C ボタンが押された場合
    if Input.trigger?(Input::C)
      # スキルウィンドウで現在選択されているデータを取得
      @skill = @skill_window.skill
      # 使用できない場合
      if @skill == nil or not @actor.skill_can_use?(@skill.id)
        # ブザー SE を演奏
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # 決定 SE を演奏
      $game_system.se_play($data_system.decision_se)
      # 効果範囲が味方の場合
      if @skill.scope >= 3
        # ターゲットウィンドウをアクティブ化
        @skill_window.active = false
        @target_window.x = (@skill_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # 効果範囲 (単体/全体) に応じてカーソル位置を設定
        if @skill.scope == 4 || @skill.scope == 6
          @target_window.index = -1
        elsif @skill.scope == 7
          @target_window.index = @actor_index - 10
        else
          @target_window.index = 0
        end
      # 効果範囲が味方以外の場合
      else
        # コモンイベント ID が有効の場合
        if @skill.common_event_id > 0
          # コモンイベント呼び出し予約
          $game_temp.common_event_id = @skill.common_event_id
          # スキルの使用時 SE を演奏
          $game_system.se_play(@skill.menu_se)
          # SP 消費
          @actor.ssp -= @skill.ssp_cost
          @actor.sp -= @skill.sp_cost
          # 各ウィンドウの内容を再作成
          @status_window.refresh
          @skill_window.refresh
          @target_window.refresh
          # マップ画面に切り替え
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
    # R ボタンが押された場合
    if Input.trigger?(Input::R)
      # カーソル SE を演奏
      $game_system.se_play($data_system.cursor_se)
      # 次のアクターへ
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # 別のスキル画面に切り替え
      $scene = Scene_Skill.new(@actor_index)
      return
    end
    # L ボタンが押された場合
    if Input.trigger?(Input::L)
      # カーソル SE を演奏
      $game_system.se_play($data_system.cursor_se)
      # 前のアクターへ
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # 別のスキル画面に切り替え
      $scene = Scene_Skill.new(@actor_index)
      return
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (ターゲットウィンドウがアクティブの場合)
  #--------------------------------------------------------------------------
  def update_target
    # B ボタンが押された場合
    if Input.trigger?(Input::B)
      # キャンセル SE を演奏
      $game_system.se_play($data_system.cancel_se)
      # ターゲットウィンドウを消去
      @skill_window.active = true
      @target_window.visible = false
      @target_window.active = false
      return
    end
    # C ボタンが押された場合
    if Input.trigger?(Input::C)
      # SP 切れなどで使用できなくなった場合
      unless @actor.skill_can_use?(@skill.id)
        # ブザー SE を演奏
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # ターゲットが全体の場合
      if @target_window.index == -1
        # パーティ全体にスキルの使用効果を適用
        used = false
        for i in $game_party.actors
          used |= i.skill_effect(@actor, @skill)
        end
      end
      # ターゲットが使用者の場合
      if @target_window.index <= -2
        # ターゲットのアクターにスキルの使用効果を適用
        target = $game_party.actors[@target_window.index + 10]
        used = target.skill_effect(@actor, @skill)
      end
      # ターゲットが単体の場合
      if @target_window.index >= 0
        # ターゲットのアクターにスキルの使用効果を適用
        target = $game_party.actors[@target_window.index]
        used = target.skill_effect(@actor, @skill)
      end
      # スキルを使った場合
      if used
        # スキルの使用時 SE を演奏
        $game_system.se_play(@skill.menu_se)
        # SP 消費
          @actor.ssp -= @skill.ssp_cost
          @actor.sp -= @skill.sp_cost
        # 各ウィンドウの内容を再作成
        @status_window.refresh
        @skill_window.refresh
        @target_window.refresh
        # 全滅の場合
        if $game_party.all_dead?
          # ゲームオーバー画面に切り替え
          $scene = Scene_Gameover.new
          return
        end
        # コモンイベント ID が有効の場合
        if @skill.common_event_id > 0
          # コモンイベント呼び出し予約
          $game_temp.common_event_id = @skill.common_event_id
          # マップ画面に切り替え
          $scene = Scene_Map.new
          return
        end
      end
      # スキルを使わなかった場合
      unless used
        # ブザー SE を演奏
        $game_system.se_play($data_system.buzzer_se)
       end
      return
    end
  end
end
end