KGC파라미터배분2 스크립트입니다.

2009년7월19일 최종갱신.

 

사용법은 기존 파라미터 배분과 동일한것 같군요.

 

 

 

 

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ 파라미터 배분 2 - KGC_DistributeParameter2 ◆ VX ◆
#_/    ◇ Last update : 2009/07/18 ◇
#_/----------------------------------------------------------------------------
#_/  파라미터 배분 기능을 작성합니다.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ 커스터마이즈 항목 - Customize ★
#==============================================================================

module KGC
module DistributeParameter
  # ◆ 파라미터 배분 개소
  #  배분 개소 및 증가량을
  #   {
  #     :key        => 키,
  #     :name       => "명칭",
  #     :limit      => 회수 상한,
  #     :cost       => [소비 RP, 소비 RP 보정],
  #     :파라미터 => [상승량, 상승량 보정],
  #     # 이후, 파라미터를 필요한 만큼 기술
  #   },
  #  그렇다고 하는 서식에서 추가.
  #  배분 화면에서는, 추가한 순서에 표시.
  #  「키」에는, 다른 개소로 입지 않는 명칭을 지정.
  #  (내부에서 배분 개소를 특정하기 위해서 사용.수치, 문자열등 뭐든지OK)
  #  「회수 상한」이외는 소수에서도OK.
  #  「회수 상한」을 0 (으)로 하면 회수 무제한.
  #  「소비 RP 보정」과「상승량 보정」은 생략가능.생략시는 0.
  GAIN_PARAMETER = [
    {
      :key   => :health,
      :name  => "체력",
      :limit => 30,
      :cost  => [ 1, 0.4],
      :maxhp => [30, 2],
      :def   => [ 1, 0.25],
    },
    {
      :key   => :magic,
      :name  => "마력",
      :limit => 30,
      :cost  => [1, 0.4],
      :maxmp => [5, 0.5],
      :spi   => [2, 0.5],
    },
    {
      :key   => :pow,
      :name  => "힘",
      :limit => 30,
      :cost  => [1, 0.4],
      :atk   => [2, 0.5],
      :def   => [1, 0.25],
    },
    {
      :key   => :dex,
      :name  => "민첩함",
      :limit => 30,
      :cost  => [1, 0.4],
      :agi   => [2, 0.5],
      :hit   => [0.5],
      :eva   => [0.5],
    },
    {
      :key   => :hit,
      :name  => "명중율",
      :limit => 20,
      :cost  => [1, 0.5],
      :hit   => [1],
    },
    {
      :key   => :eva,
      :name  => "회피율",
      :limit => 20,
      :cost  => [1, 0.5],
      :eva   => [1],
    },
    {
      :key   => :crt,
      :name  => "위기",
      :limit => 20,
      :cost  => [1, 0.7],
      :cri   => [1],
    },
    {
      :key         => :chant,
      :name        => "영창 속도",
      :limit       => 0,
      :cost        => [1, 0.5],
      :skill_speed => [1],
    },
    {
      :key        => :item,
      :name       => "아이템 속도",
      :limit      => 0,
      :cost       => [1, 0.5],
      :item_speed => [1],
    },
    {
      :key   => :odds,
      :name  => "표적이 되기 쉬움",
      :limit => 5,
      :cost  => [1],
      :odds  => [1],
    }
  ]  # ← 이 ] (은)는 지우지 않는 것!

  # ◆ 액터 고유의 파라미터 증가량
  PERSONAL_GAIN_PARAMETER = []
  #  여기에서 아래로, 액터마다의 배분시의 증가량을
  #   PERSONAL_GAIN_PARAMETER[액터 ID] = [ 배분 개소 ]
  #  그렇다고 하는 서식에서 지정.
  #  「배분 개소」는 GAIN_PARAMETER (와)과 같은 서식.
  #  키가 GAIN_PARAMETER (와)과 같은 경우,GAIN_PARAMETER 에 덧쓰기.
  #  지정하지 않았던 파라미터/액터는 GAIN_PARAMETER (을)를 사용.
  #
  # <례> 액터 1의 "체력" (을)를 개별적으로 지정.
  PERSONAL_GAIN_PARAMETER[1] = [
    {
      :key   => :health,
      :name  => "체력",
      :limit => 30,
      :cost  => [ 1, 0.4],
      :maxhp => [50, 3],
      :def   => [ 1, 0.3],
    },
  ]

  # ◆ 직업 고유의 파라미터 증가량
  CLASS_GAIN_PARAMETER = []
  #  여기에서 아래로, 직업마다의 배분시의 증가량을
  #   CLASS_GAIN_PARAMETER[직업 ID] = [ 배분 개소 ]
  #  그렇다고 하는 서식에서 지정.
  #  그 외는 액터 고유의 설정과 같이.
  #  (우선도는  직업 ＞ 액터 ＞ 디폴트)

  # ◆ RP (Reinforce Point) 의 명칭
  VOCAB_RP   = "RP"
  # ◆ RP 의 명칭 (략)
  VOCAB_RP_A = "R"

  # ◆ MaxRP 계산식
  #   level .. 레벨
  #  결과가 소수가 되어도OK(자동으로 정수에 변환).
  MAXRP_EXP = "(level ** 0.25 + 2.0) * level"

  # ◆ 파라미터명
  #  ≪확장 장비 화면≫ (와)과 병용 했을 경우, 아래에 도입한 (분)편을 우선.
  VOCAB_PARAM = {
    :hit         => "명중율",        # 명중율
    :eva         => "회피율",        # 회피율
    :cri         => "위기",  # 위기율
    :skill_speed => "영창 속도",      # 스킬 속도 보정
    :item_speed  => "아이템 속도",  # 아이템 속도 보정
    :odds        => "표적이 되기 쉬움",  # 표적이 되기 쉬움
  }  # ← 이 } (은)는 지우지 않는 것!

  # ◆ 배분 회수가 무제한 때는 /--- (상한 표기) (을)를 숨긴다
  #  true  : 회수만 표시
  #  false : 회수/--- (와)과 표시
  HIDE_MAX_COUNT_INFINITE  = false

  # ◆ 배분 게이지의 개시색
  #  수치  : C[n] (와)과 같은 색.
  #  Color : 지정한 색. ( Color.new(255, 128, 128) 등 )
  GAUGE_START_COLOR = 28
  # ◆ 배분 게이지의 종료색
  GAUGE_END_COLOR   = 29

  # ◆ 배분 종료시의 확인 커멘드
  CONFIRM_COMMANDS = [
    "확정",  # 배분 확정
    "중지",  # 배분 중지
    "돌아온다",  # 배분을 계속한다
  ]  # ← 이 ] (은)는 지우지 않는 것!

  # ◆ 확인 커멘드의 헬프
  CONFIRM_COMMAND_HELP = [
    "배분 조작을 확정합니다.",        # 배분 확정
    "이번 배분 조작을 파기합니다.",  # 배분 중지
    "배분을 계속합니다.",              # 배분을 계속한다
  ]  # ← 이 ] (은)는 지우지 않는 것!

  # ◆ 배분 종료시의 확인 커멘드의 폭
  CONFIRM_WIDTH = 96

  # ◆ 메뉴 화면에 「파라미터 배분해」커멘드를 추가한다
  #  추가하는 장소는, 메뉴 커멘드의 최하부입니다.
  #  다른 부분에 추가하고 싶으면,≪커스텀 메뉴 커멘드≫ (을)를 이용하십시오.
  USE_MENU_DISTRIBUTE_PARAMETER_COMMAND = true
  # ◆ 메뉴 화면의 「파라미터 배분해」커멘드의 명칭
  VOCAB_MENU_DISTRIBUTE_PARAMETER       = "파라미터 배분"

  # ◆ 배분 해제를 허가
  #  true  : 배분 확정 후도 파라미터를 내려RP (을)를 되찾을 수 있다.
  #  false : 한 번 확정하면 내릴 수 없다.
  ENABLE_REVERSE_DISTRIBUTE = true
end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

$imported = {} if $imported == nil
$imported["DistributeParameter"] = true

module KGC::DistributeParameter
  # 배분 대상 파라미터
  PARAMS = [:maxhp, :maxmp, :atk, :def, :spi, :agi, :hit, :eva, :cri,
    :skill_speed, :item_speed, :odds]

  # 파라미터 증가량 구조체
  GainInfo  = Struct.new(:key, :name, :limit, :cost, :cost_rev, :params)
  ParamInfo = Struct.new(:value, :value_rev)

  # 배분 정보 구조체
  DistInfo = Struct.new(:count, :hp, :mp)

  #--------------------------------------------------------------------------
  # ○ 파라미터 증가량을 구조체화
  #--------------------------------------------------------------------------
  def self.create_gain_param_structs(target)
    result = []
    target.each { |v|
      info = GainInfo.new
      info.key      = v[:key]
      info.name     = v[:name]
      info.limit    = v[:limit]
      info.cost     = v[:cost][0]
      info.cost_rev = (v[:cost][1] == nil ? 0 : v[:cost][1])
      info.params   = {}

      PARAMS.each { |param|
        next unless v.has_key?(param)
        pinfo = ParamInfo.new
        pinfo.value     = v[param][0]
        pinfo.value_rev = (v[param][1] == nil ? 0 : v[param][1])
        info.params[param] = pinfo
      }
      result << info
    }
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 증가량을 구조체화 (고유 증가량용)
  #--------------------------------------------------------------------------
  def self.create_gain_param_structs_for_personal(target)
    result = []
    target.each { |list|
      next if list == nil
      result << create_gain_param_structs(list)
    }
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 증가량을 병합
  #--------------------------------------------------------------------------
  def self.merge(list1, list2)
    result = list1.clone
    list2.each { |info2|
      overwrite = false
      list1.each_with_index { |info1, i|
        if info1.key == info2.key
          result[i] = info2
          overwrite = true
          break
        end
      }
      result << info2 unless overwrite
    }
    return result
  end

  # 파라미터 증가량을 구조체화
  GAIN_PARAMS = create_gain_param_structs(GAIN_PARAMETER)
  PERSONAL_GAIN_PARAMS =
    create_gain_param_structs_for_personal(PERSONAL_GAIN_PARAMETER)
  CLASS_GAIN_PARAMS =
    create_gain_param_structs_for_personal(CLASS_GAIN_PARAMETER)
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Vocab
#==============================================================================

module Vocab
  # 명중율
  def self.hit
    return KGC::DistributeParameter::VOCAB_PARAM[:hit]
  end

  # 회피율
  def self.eva
    return KGC::DistributeParameter::VOCAB_PARAM[:eva]
  end

  # 위기율
  def self.cri
    return KGC::DistributeParameter::VOCAB_PARAM[:cri]
  end

  # 스킬 속도 보정
  def self.skill_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:skill_speed]
  end

  # 아이템 속도 보정
  def self.item_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:item_speed]
  end

  # 표적이 되기 쉬움
  def self.odds
    return KGC::DistributeParameter::VOCAB_PARAM[:odds]
  end

  # RP
  def self.rp
    return KGC::DistributeParameter::VOCAB_RP
  end

  # RP (략)
  def self.rp_a
    return KGC::DistributeParameter::VOCAB_RP_A
  end

  # 파라미터 배분
  def self.distribute_parameter
    return KGC::DistributeParameter::VOCAB_MENU_DISTRIBUTE_PARAMETER
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ KGC::Commands
#==============================================================================

module KGC
module Commands
  module_function
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분해에 관한 값을 체크
  #--------------------------------------------------------------------------
  def check_distribution_values
    (1...$data_actors.size).each { |i|
      actor = $game_actors[i]
      actor.check_distribution_values
      actor.restore_distribution_values
    }
  end
  #--------------------------------------------------------------------------
  # ○ RP 의 증감
  #     actor_id : 액터 ID
  #     value    : 증감량
  #--------------------------------------------------------------------------
  def gain_rp(actor_id, value)
    actor = $game_actors[actor_id]
    return if actor == nil
    actor.gain_rp(value)
  end
  #--------------------------------------------------------------------------
  # ○ 배분 회수를 리셋트
  #     actor_id : 액터 ID
  #--------------------------------------------------------------------------
  def reset_distributed_count(actor_id)
    actor = $game_actors[actor_id]
    return if actor == nil
    actor.clear_distribution_values
    actor.restore_distribution_values
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분 화면의 호출
  #     actor_index : 액터 인덱스
  #--------------------------------------------------------------------------
  def call_distribute_parameter(actor_index = 0)
    return if $game_temp.in_battle
    $game_temp.next_scene = :distribute_parameter
    $game_temp.next_scene_actor_index = actor_index
  end
end
end

class Game_Interpreter
  include KGC::Commands
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

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

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 능력치에 가산하는 값을 클리어
  #--------------------------------------------------------------------------
  alias clear_extra_values_KGC_DistributeParameter clear_extra_values
  def clear_extra_values
    clear_extra_values_KGC_DistributeParameter

    clear_distribution_values
    calc_distribution_values
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분해에 관한 값을 클리어
  #--------------------------------------------------------------------------
  def clear_distribution_values
    @distributed_count = {}
    KGC::DistributeParameter::PARAMS.each { |param|
      @distributed_count[param] = 0
    }
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분해에 관한 값을 체크
  #--------------------------------------------------------------------------
  def check_distribution_values
    last_distributed_count = @distributed_count

    clear_distribution_values

    @distributed_count = last_distributed_count if last_distributed_count != nil
  end
  #--------------------------------------------------------------------------
  # ○ 각종 수정치를 계산
  #--------------------------------------------------------------------------
  def calc_distribution_values
    # 계승처에서 정의
  end
  #--------------------------------------------------------------------------
  # ○ 배분에 의한 상승치를 취득
  #     param : 파라미터의 Symbol
  #--------------------------------------------------------------------------
  def distributed_param(param)
    return 0
  end
  #--------------------------------------------------------------------------
  # ○ 배분해에 관한 정보를 취득
  #--------------------------------------------------------------------------
  def distribution_info
    info = KGC::DistributeParameter::DistInfo.new
    info.count = @distributed_count.clone
    info.hp    = self.hp
    info.mp    = self.mp
    return info
  end
  #--------------------------------------------------------------------------
  # ○ 배분해에 관한 정보를 설정
  #--------------------------------------------------------------------------
  def set_distribution_info(info)
    return unless info.is_a?(KGC::DistributeParameter::DistInfo)

    @distributed_count = info.count
    calc_distribution_values
    self.hp = info.hp
    self.mp = info.mp
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_BattleAction
#==============================================================================

class Game_BattleAction
  #--------------------------------------------------------------------------
  # ● 행동 스피드의 결정
  #--------------------------------------------------------------------------
  alias make_speed_KGC_DistributeParameter make_speed
  def make_speed
    make_speed_KGC_DistributeParameter

    if skill?
      n = [battler.distributed_param(:skill_speed), skill.speed].min
      @speed -= n
    end
    if item?
      n = [battler.distributed_param(:item_speed), item.speed].min
      @speed -= n
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ○ 클래스 변수
  #--------------------------------------------------------------------------
  @@__distribute_gain_params = {}
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     actor_id : 액터 ID
  #--------------------------------------------------------------------------
  alias initialize_KGC_DistributeParameter initialize
  def initialize(actor_id)
    @actor_id = actor_id
    @class_id = $data_actors[actor_id].class_id

    initialize_KGC_DistributeParameter(actor_id)
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 증가량 일람을 취득
  #--------------------------------------------------------------------------
  def gain_parameter_list
    key = "#{self.id}_#{self.class_id}"
    unless @@__distribute_gain_params.has_key?(key)
      result = KGC::DistributeParameter::GAIN_PARAMS
      # 액터 고유
      list = KGC::DistributeParameter::PERSONAL_GAIN_PARAMS[self.id]
      result = KGC::DistributeParameter.merge(result, list) if list != nil
      # 직업 고유
      list = KGC::DistributeParameter::CLASS_GAIN_PARAMS[self.class_id]
      result = KGC::DistributeParameter.merge(result, list) if list != nil

      @@__distribute_gain_params[key] = result
    end

    return @@__distribute_gain_params[key]
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 증가량을 취득
  #     key : 배분 키
  #--------------------------------------------------------------------------
  def gain_parameter(key)
    return gain_parameter_list.find { |v| v.key == key }
  end
  #--------------------------------------------------------------------------
  # ○ 각종 수정치를 계산
  #--------------------------------------------------------------------------
  def calc_distribution_values
    @rp_cost = 0
    @distributed_param = {}
    KGC::DistributeParameter::PARAMS.each { |param|
      @distributed_param[param] = 0
    }

    gain_parameter_list.each { |gain|
      next if gain == nil
      cost = 0
      distributed_count(gain.key).times { |i|
        cost += Integer(gain.cost + gain.cost_rev * i)
        gain.params.each { |param, v|
          @distributed_param[param] += v.value + v.value_rev * i
        }
      }
      @rp_cost += [cost, 0].max
    }

    KGC::DistributeParameter::PARAMS.each { |param|
      @distributed_param[param] = Integer(@distributed_param[param])
    }
  end
  #--------------------------------------------------------------------------
  # ○ 각종 수정치를 수복
  #--------------------------------------------------------------------------
  def restore_distribution_values
    calc_distribution_values
    self.hp = self.hp
    self.mp = self.mp
  end
  #--------------------------------------------------------------------------
  # ○ 배분에 의한 상승치를 취득
  #     param : 파라미터의 Symbol
  #--------------------------------------------------------------------------
  def distributed_param(param)
    return 0 if @distributed_param == nil
    return 0 if @distributed_param[param] == nil
    return @distributed_param[param]
  end
  #--------------------------------------------------------------------------
  # ● 기본 MaxHP 의 취득
  #--------------------------------------------------------------------------
  alias base_maxhp_KGC_DistributeParameter base_maxhp
  def base_maxhp
    n = base_maxhp_KGC_DistributeParameter + distributed_param(:maxhp)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 MaxMP 의 취득
  #--------------------------------------------------------------------------
  alias base_maxmp_KGC_DistributeParameter base_maxmp
  def base_maxmp
    n = base_maxmp_KGC_DistributeParameter + distributed_param(:maxmp)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 공격력의 취득
  #--------------------------------------------------------------------------
  alias base_atk_KGC_DistributeParameter base_atk
  def base_atk
    n = base_atk_KGC_DistributeParameter + distributed_param(:atk)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 방어력의 취득
  #--------------------------------------------------------------------------
  alias base_def_KGC_DistributeParameter base_def
  def base_def
    n = base_def_KGC_DistributeParameter + distributed_param(:def)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 정신력의 취득
  #--------------------------------------------------------------------------
  alias base_spi_KGC_DistributeParameter base_spi
  def base_spi
    n = base_spi_KGC_DistributeParameter + distributed_param(:spi)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 민첩성의 취득
  #--------------------------------------------------------------------------
  alias base_agi_KGC_DistributeParameter base_agi
  def base_agi
    n = base_agi_KGC_DistributeParameter + distributed_param(:agi)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 명중율의 취득
  #--------------------------------------------------------------------------
  alias hit_KGC_DistributeParameter hit
  def hit
    n = hit_KGC_DistributeParameter + distributed_param(:hit)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 회피율의 취득
  #--------------------------------------------------------------------------
  alias eva_KGC_DistributeParameter eva
  def eva
    n = eva_KGC_DistributeParameter + distributed_param(:eva)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 위기율의 취득
  #--------------------------------------------------------------------------
  alias cri_KGC_DistributeParameter cri
  def cri
    n = cri_KGC_DistributeParameter + distributed_param(:cri)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 표적이 되기 쉬움의 취득
  #--------------------------------------------------------------------------
  alias odds_KGC_DistributeParameter odds
  def odds
    n = odds_KGC_DistributeParameter + distributed_param(:odds)
    return n
  end
  #--------------------------------------------------------------------------
  # ○ MaxRP 의 취득
  #--------------------------------------------------------------------------
  def maxrp
    n = Integer(eval(KGC::DistributeParameter::MAXRP_EXP))
    return [n + maxrp_plus, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ MaxRP 보정치의 취득
  #--------------------------------------------------------------------------
  def maxrp_plus
    @maxrp_plus = 0 if @maxrp_plus == nil
    return @maxrp_plus
  end
  #--------------------------------------------------------------------------
  # ○ RP 의 취득
  #--------------------------------------------------------------------------
  def rp
    return [maxrp - @rp_cost, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ 배분 회수의 취득
  #     param : 배분처 파라미터 (키)
  #--------------------------------------------------------------------------
  def distributed_count(param)
    clear_distribution_values     if @distributed_count == nil
    @distributed_count[param] = 0 if @distributed_count[param] == nil
    return @distributed_count[param]
  end
  #--------------------------------------------------------------------------
  # ○ RP 의 증감
  #     value : 증감량
  #--------------------------------------------------------------------------
  def gain_rp(value)
    @maxrp_plus = maxrp_plus + value
  end
  #--------------------------------------------------------------------------
  # ○ 배분 회수의 증감
  #     param : 배분처 파라미터 (키)
  #     value : 증감량
  #--------------------------------------------------------------------------
  def gain_distributed_count(param, value = 1)
    n = distributed_count(param)
    @distributed_count[param] += value if n.is_a?(Integer)
  end
  #--------------------------------------------------------------------------
  # ○ RP 배분에 의한 성장 효과 적용
  #     param   : 배분처 파라미터 (키)
  #     reverse : 역가산 때는 true
  #--------------------------------------------------------------------------
  def rp_growth_effect(param, reverse = false)
    gain = gain_parameter(param)
    return if gain == nil  # 무효인 파라미터

    if reverse
      return if distributed_count(param) == 0  # 역가산 불가
    else
      return unless can_distribute?(param)
    end

    gain_distributed_count(param, reverse ? -1 : 1)
    restore_distribution_values
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분 가부 판정
  #     param : 배분처 파라미터 (키)
  #--------------------------------------------------------------------------
  def can_distribute?(param)
    gain = gain_parameter(param)
    return false if gain == nil                        # 무효인 파라미터
    return false if self.rp < distribute_cost(param)   # RP 부족
    if gain.limit > 0
      return false if gain.limit <= distributed_count(param)  # 회수 상한
    end

    return true
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분 코스트 계산
  #     param : 배분처 파라미터 (키)
  #--------------------------------------------------------------------------
  def distribute_cost(param)
    gain = gain_parameter(param)
    return 0 if gain == nil  # 무효인 파라미터

    n = gain.cost
    count = distributed_count(param)
    count = [count, gain.limit - 1].min if gain.limit > 0
    n += gain.cost_rev * count
    return [Integer(n), 0].max
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분 후의 증가량 계산
  #     param : 배분처 파라미터 (키)
  #     amt   : 배분수
  #--------------------------------------------------------------------------
  def distribute_gain(param, amt = 1)
    gain = gain_parameter(param)
    # 무효인 파라미터
    return 0 if gain == nil
    # 배분 불가
    if amt > 0
      return 0 if gain.limit > 0 && gain.limit == distributed_count(param)
    else
      return 0 if distributed_count(param) + amt < 0
    end

    last_hp = self.hp
    last_mp = self.mp
    result  = {}
    KGC::DistributeParameter::PARAMS.each { |par|
      result[par] = distributed_param(par)
    }
    last_count = distributed_count(param)
    rp_growth_effect(param)
    KGC::DistributeParameter::PARAMS.each { |par|
      result[par] = distributed_param(par) if gain.params.include?(par)
    }
    rp_growth_effect(param, true) if last_count < distributed_count(param)
    self.hp = last_hp
    self.mp = last_mp
    return result
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ RP 의 문자색을 취득
  #     actor : 액터
  #--------------------------------------------------------------------------
  def rp_color(actor)
    return (actor.rp == 0 ? knockout_color : normal_color)
  end
  #--------------------------------------------------------------------------
  # ○ 배분 게이지의 색 1 의 취득
  #--------------------------------------------------------------------------
  def distribute_gauge_color1
    color = KGC::DistributeParameter::GAUGE_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ 배분 게이지의 색 2 의 취득
  #--------------------------------------------------------------------------
  def distribute_gauge_color2
    color = KGC::DistributeParameter::GAUGE_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ RP 의 묘화
  #     actor : 액터
  #     x     : 묘화처 X 좌표
  #     y     : 묘화처 Y 좌표
  #     width : 폭
  #--------------------------------------------------------------------------
  def draw_actor_rp(actor, x, y, width = 120)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 40, WLH, Vocab::rp_a)
    self.contents.font.color = rp_color(actor)
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 40, y, 40, WLH, actor.rp, 2)
    else
      self.contents.draw_text(xr - 90, y, 40, WLH, actor.rp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 50, y, 10, WLH, "/", 2)
      self.contents.draw_text(xr - 40, y, 40, WLH, actor.maxrp, 2)
    end
    self.contents.font.color = normal_color
  end
  #--------------------------------------------------------------------------
  # ○ 배분 게이지의 묘화
  #     actor : 액터
  #     param : 파라미터
  #     x     : 묘화처 X 좌표
  #     y     : 묘화처 Y 좌표
  #     width : 폭
  #--------------------------------------------------------------------------
  def draw_actor_distribute_gauge(actor, param, x, y, width = 120)
    gain = actor.gain_parameter(param)
    return if gain == nil || gain.limit <= 0
    gw = width * actor.distributed_count(param) / gain.limit
    gc1 = distribute_gauge_color1
    gc2 = distribute_gauge_color2
    self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Command
#==============================================================================

class Window_Command < Window_Selectable
  unless method_defined?(:add_command)
  #--------------------------------------------------------------------------
  # ○ 커멘드를 추가
  #    추가한 위치를 돌려준다
  #--------------------------------------------------------------------------
  def add_command(command)
    @commands << command
    @item_max = @commands.size
    item_index = @item_max - 1
    refresh_command
    draw_item(item_index)
    return item_index
  end
  #--------------------------------------------------------------------------
  # ○ 커멘드를 리프레쉬
  #--------------------------------------------------------------------------
  def refresh_command
    buf = self.contents.clone
    self.height = [self.height, row_max * WLH + 32].max
    create_contents
    self.contents.blt(0, 0, buf, buf.rect)
    buf.dispose
  end
  #--------------------------------------------------------------------------
  # ○ 커멘드를 삽입
  #--------------------------------------------------------------------------
  def insert_command(index, command)
    @commands.insert(index, command)
    @item_max = @commands.size
    refresh_command
    refresh
  end
  #--------------------------------------------------------------------------
  # ○ 커멘드를 삭제
  #--------------------------------------------------------------------------
  def remove_command(command)
    @commands.delete(command)
    @item_max = @commands.size
    refresh
  end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Window_DistributeParameterActor
#------------------------------------------------------------------------------
#   배분 화면에서, 액터의 정보를 표시하는 윈도우입니다.
#==============================================================================

class Window_DistributeParameterActor < Window_Base
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     x     : 윈도우의 X 좌표
  #     y     : 윈도우의 Y 좌표
  #     actor : 액터
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, Graphics.width, WLH + 32)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 리프레쉬
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 140, 0)
    draw_actor_rp(@actor, 240, 0)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Window_DistributeParameterList
#------------------------------------------------------------------------------
#   배분 화면에서, 성장시키는 파라미터를 선택하는 윈도우입니다.
#==============================================================================

class Window_DistributeParameterList < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     actor : 액터
  #--------------------------------------------------------------------------
  def initialize(actor)
    off_h = WLH + 32
    super(0, off_h, 286, Graphics.height - off_h)
    @actor = actor
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # ○ 선택중의 파라미터의 Symbol (을)를 취득
  #--------------------------------------------------------------------------
  def parameter_key
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ● 1 페이지에 표시할 수 있는 행수의 취득
  #--------------------------------------------------------------------------
  def page_row_max
    return super - 1
  end
  #--------------------------------------------------------------------------
  # ● 항목을 묘화 하는 구형의 취득
  #     index : 항목 번호
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super(index)
    rect.y += WLH
    return rect
  end
  #--------------------------------------------------------------------------
  # ● 커서를 1 페이지 뒤로 이동
  #--------------------------------------------------------------------------
  def cursor_pagedown
    return if Input.repeat?(Input::R)
    super
  end
  #--------------------------------------------------------------------------
  # ● 커서를 1 페이지전에 이동
  #--------------------------------------------------------------------------
  def cursor_pageup
    return if Input.repeat?(Input::L)
    super
  end
  #--------------------------------------------------------------------------
  # ● 리프레쉬
  #--------------------------------------------------------------------------
  def refresh
    @gain_list = @actor.gain_parameter_list
    @data = []
    @gain_list.each { |gain| @data << gain.key }
    @item_max = @data.size + 1
    create_contents
    @item_max -= 1
    draw_caption
    @item_max.times { |i| draw_item(i, @actor.can_distribute?(@data[i])) }
  end
  #--------------------------------------------------------------------------
  # ○ 표제의 묘화
  #--------------------------------------------------------------------------
  def draw_caption
    self.contents.font.color = system_color
    self.contents.draw_text(  4, 0, 96, WLH, "파라미터")
    self.contents.draw_text(120, 0, 40, WLH, Vocab.rp, 2)
    self.contents.draw_text(170, 0, 80, WLH, "회수", 2)
    self.contents.font.color = normal_color
  end
  #--------------------------------------------------------------------------
  # ○ 항목의 묘화
  #     index   : 항목 번호
  #     enabled : 유효 플래그
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      draw_parameter(rect.x, rect.y, @data[index], enabled)
    end
  end
  #--------------------------------------------------------------------------
  # ○ 능력치의 묘화
  #     x       : 묘화처 X 좌표
  #     y       : 묘화처 Y 좌표
  #     param   : 배분처
  #     enabled : 유효 플래그
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, param, enabled)
    gain = @gain_list.find { |v| v.key == param }
    return if gain == nil

    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(x + 4, y, 96, WLH, gain.name)

    value = @actor.distribute_cost(param)
    self.contents.draw_text(x + 120, y, 40, WLH, value, 2)
    if gain.limit > 0
      value = sprintf("%3d/%3d", @actor.distributed_count(param), gain.limit)
    else
      value = sprintf("%3d%s", @actor.distributed_count(param),
        KGC::DistributeParameter::HIDE_MAX_COUNT_INFINITE ? "" : "/---")
    end
    draw_actor_distribute_gauge(@actor, param, x + 170, y, 80)
    self.contents.draw_text(x + 170, y, 80, WLH, value, 2)
    self.contents.font.color = normal_color
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Window_DistributeParameterStatus
#------------------------------------------------------------------------------
#   배분 화면에서, 액터의 스테이터스를 표시하는 윈도우입니다.
#==============================================================================

class Window_DistributeParameterStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     actor : 액터
  #--------------------------------------------------------------------------
  def initialize(actor)
    dx = 286
    off_h = WLH + 32
    super(dx, off_h, Graphics.width - dx, Graphics.height - off_h)
    @actor = actor
    refresh(actor.gain_parameter_list[0].key)
  end
  #--------------------------------------------------------------------------
  # ● 리프레쉬
  #--------------------------------------------------------------------------
  def refresh(param = nil)
    @parameter_key = param

    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(0, 0, width - 32, WLH, "파라미터 변화", 1)
    self.contents.font.color = normal_color
    dy = WLH
    KGC::DistributeParameter::PARAMS.each { |param|
      draw_parameter(0, dy, param)
      dy += WLH
    }
  end
  #--------------------------------------------------------------------------
  # ○ 능력치의 묘화
  #     x    : 묘화처 X 좌표
  #     y    : 묘화처 Y 좌표
  #     type : 능력치의 종류
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type)
    case type
    when :maxhp
      name  = Vocab.hp
      value = @actor.maxhp
    when :maxmp
      name  = Vocab.mp
      value = @actor.maxmp
    when :atk
      name  = Vocab.atk
      value = @actor.atk
    when :def
      name  = Vocab.def
      value = @actor.def
    when :spi
      name  = Vocab.spi
      value = @actor.spi
    when :agi
      name  = Vocab.agi
      value = @actor.agi
    when :hit
      name  = Vocab.hit
      value = @actor.hit
    when :eva
      name  = Vocab.eva
      value = @actor.eva
    when :cri
      name  = Vocab.cri
      value = @actor.cri
    when :skill_speed
      name  = Vocab.skill_speed
      value = @actor.distributed_param(type)
    when :item_speed
      name  = Vocab.item_speed
      value = @actor.distributed_param(type)
    when :odds
      name  = Vocab.odds
      value = @actor.odds
    else
      return
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x + 4, y, 96, WLH, name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 106, y, 48, WLH, value, 2)
   
    return if @parameter_key == nil

    self.contents.draw_text(x + 154, y, 16, WLH, "→", 1)

    last = @actor.distributed_param(type)
    gain = @actor.distribute_gain(@parameter_key)[type]
    self.contents.font.color = (gain > last ? text_color(3) :
      gain < last ? text_color(2) : normal_color)
    self.contents.draw_text(x + 174, y, 48, WLH, value + (gain - last), 2)

    self.contents.font.color = normal_color
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Map
#==============================================================================

class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # ● 화면 변환의 실행
  #--------------------------------------------------------------------------
  alias update_scene_change_KGC_DistributeParameter update_scene_change
  def update_scene_change
    return if $game_player.moving?    # 플레이어의 이동중?

    if $game_temp.next_scene == :distribute_parameter
      call_distribute_parameter
      return
    end

    update_scene_change_KGC_DistributeParameter
  end
  #--------------------------------------------------------------------------
  # ○ 파라미터 배분 화면에의 변환
  #--------------------------------------------------------------------------
  def call_distribute_parameter
    $game_temp.next_scene = nil
    $scene = Scene_DistributeParameter.new(
      $game_temp.next_scene_actor_index,
      0,
      Scene_DistributeParameter::HOST_MAP)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Menu
#==============================================================================

class Scene_Menu < Scene_Base
  if KGC::DistributeParameter::USE_MENU_DISTRIBUTE_PARAMETER_COMMAND
  #--------------------------------------------------------------------------
  # ● 커멘드 윈도우의 작성
  #--------------------------------------------------------------------------
  alias create_command_window_KGC_DistributeParameter create_command_window
  def create_command_window
    create_command_window_KGC_DistributeParameter

    return if $imported["CustomMenuCommand"]

    @__command_distribute_parameter_index =
      @command_window.add_command(Vocab.distribute_parameter)
    if @command_window.oy > 0
      @command_window.oy -= Window_Base::WLH
    end
    @command_window.index = @menu_index
  end
  end
  #--------------------------------------------------------------------------
  # ● 커멘드 선택의 갱신
  #--------------------------------------------------------------------------
  alias update_command_selection_KGC_DistributeParameter update_command_selection
  def update_command_selection
    call_distribute_parameter_flag = false
    if Input.trigger?(Input::C)
      case @command_window.index
      when @__command_distribute_parameter_index  # 파라미터 배분
        call_distribute_parameter_flag = true
      end
    end

    # 파라미터 배분 화면에 이행
    if call_distribute_parameter_flag
      if $game_party.members.size == 0
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      start_actor_selection
      return
    end

    update_command_selection_KGC_DistributeParameter
  end
  #--------------------------------------------------------------------------
  # ● 액터 선택의 갱신
  #--------------------------------------------------------------------------
  alias update_actor_selection_KGC_DistributeParameter update_actor_selection
  def update_actor_selection
    if Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      case @command_window.index
      when @__command_distribute_parameter_index  # 파라미터 배분
        $scene = Scene_DistributeParameter.new(
          @status_window.index,
          @__command_distribute_parameter_index,
          Scene_DistributeParameter::HOST_MENU)
        return
      end
    end

    update_actor_selection_KGC_DistributeParameter
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Scene_DistributeParameter
#------------------------------------------------------------------------------
#   파라미터 배분 화면의 처리를 실시하는 클래스입니다.
#==============================================================================

class Scene_DistributeParameter < Scene_Base
  #--------------------------------------------------------------------------
  # ○ 정수
  #--------------------------------------------------------------------------
  HOST_MENU   = 0  # 호출원 : 메뉴
  HOST_MAP    = 1  # 호출원 : 맵
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     actor_index : 액터 인덱스
  #     menu_index  : 커멘드의 커서 초기 위치
  #     host_scene  : 호출원 (0..메뉴  1..맵)
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, menu_index = 0, host_scene = HOST_MENU)
    @actor_index = actor_index
    @menu_index  = menu_index
    @host_scene  = host_scene
  end
  #--------------------------------------------------------------------------
  # ● 개시 처리
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background

    @actor     = $game_party.members[@actor_index]
    @prev_info = @actor.distribution_info
    create_windows
  end
  #--------------------------------------------------------------------------
  # ○ 윈도우 작성
  #--------------------------------------------------------------------------
  def create_windows
    @actor_window     = Window_DistributeParameterActor.new(0, 0, @actor)
    @parameter_window = Window_DistributeParameterList.new(@actor)
    @status_window    = Window_DistributeParameterStatus.new(@actor)

    @confirm_help_window   = Window_Help.new
    @confirm_help_window.z = @status_window.z + 100
    @confirm_help_window.openness = 0

    @confirm_window = Window_Command.new(
      KGC::DistributeParameter::CONFIRM_WIDTH,
      KGC::DistributeParameter::CONFIRM_COMMANDS)
    @confirm_window.x = (Graphics.width  - @confirm_window.width)  / 2
    @confirm_window.y = (Graphics.height - @confirm_window.height) / 2
    @confirm_window.z = @confirm_help_window.z
    @confirm_window.active   = false
    @confirm_window.openness = 0
  end
  #--------------------------------------------------------------------------
  # ● 종료 처리
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @actor_window.dispose
    @parameter_window.dispose
    @status_window.dispose
    @confirm_help_window.dispose
    @confirm_window.dispose
  end
  #--------------------------------------------------------------------------
  # ○ 원래의 화면에 돌아온다
  #--------------------------------------------------------------------------
  def return_scene
    case @host_scene
    when HOST_MENU
      $scene = Scene_Menu.new(@menu_index)
    when HOST_MAP
      $scene = Scene_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # ● 프레임 갱신
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    update_window
    if @parameter_window.active
      update_parameter_list
    elsif @confirm_window.active
      update_confirm_command
    end
  end
  #--------------------------------------------------------------------------
  # ○ 윈도우 갱신
  #--------------------------------------------------------------------------
  def update_window
    @actor_window.update
    @parameter_window.update
    @status_window.update
    @confirm_help_window.update
    @confirm_window.update
  end
  #--------------------------------------------------------------------------
  # ○ 윈도우재묘화
  #--------------------------------------------------------------------------
  def refresh_window
    @actor_window.refresh
    @parameter_window.refresh
    @status_window.refresh(@parameter_window.parameter_key)
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # ○ 다음의 액터의 화면으로 전환해
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    $scene = Scene_DistributeParameter.new(@actor_index,
      @menu_index, @host_scene)
  end
  #--------------------------------------------------------------------------
  # ○ 전의 액터의 화면으로 전환해
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    $scene = Scene_DistributeParameter.new(@actor_index,
      @menu_index, @host_scene)
  end
  #--------------------------------------------------------------------------
  # ○ 프레임 갱신 (파라미터 윈도우가 액티브의 경우)
  #--------------------------------------------------------------------------
  def update_parameter_list
    if @last_index != @parameter_window.index
      @status_window.refresh(@parameter_window.parameter_key)
      @last_index = @parameter_window.index
    end

    if Input.trigger?(Input::B)
      Sound.play_cancel
      activate_confirm_window
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      activate_confirm_window
    elsif Input.repeat?(Input::RIGHT)
      # 가산
      param = @parameter_window.parameter_key
      unless @actor.can_distribute?(param)
        Sound.play_buzzer
        return
      end
      Sound.play_cursor
      @actor.rp_growth_effect(param)
      refresh_window
    elsif Input.repeat?(Input::LEFT)
      # 감산
      param = @parameter_window.parameter_key
      unless reversible?(param)
        Sound.play_buzzer
        return
      end
      Sound.play_cursor
      @actor.rp_growth_effect(param, true)
      refresh_window
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end
  #--------------------------------------------------------------------------
  # ○ 감산 가부 판정
  #     param : 대상 파라미터
  #--------------------------------------------------------------------------
  def reversible?(param)
    return false if @actor.distributed_count(param) == 0
    return true  if KGC::DistributeParameter::ENABLE_REVERSE_DISTRIBUTE

    base = @prev_info.count[param]
    return ( base < @actor.distributed_count(param) )
  end
  #--------------------------------------------------------------------------
  # ○ 확인 윈도우로 전환해
  #--------------------------------------------------------------------------
  def activate_confirm_window
    @last_index = -1
    @status_window.refresh
    @confirm_window.index  = 0
    @confirm_window.active = true
    @confirm_window.open
    @confirm_help_window.open
    @parameter_window.active = false
    @last_confirm_index = -1
  end
  #--------------------------------------------------------------------------
  # ○ 프레임 갱신 (확인 윈도우가 액티브의 경우)
  #--------------------------------------------------------------------------
  def update_confirm_command
    if @last_confirm_index != @confirm_window.index
      @confirm_help_window.set_text(
        KGC::DistributeParameter::CONFIRM_COMMAND_HELP[@confirm_window.index])
      @last_confirm_index = @confirm_window.index
    end

    if Input.trigger?(Input::B)
      Sound.play_cancel
      # 파라미터 윈도우로 전환해
      @confirm_window.active = false
      @confirm_window.close
      @confirm_help_window.close
      @parameter_window.active = true
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      case @confirm_window.index
      when 0  # 확정
        return_scene
      when 1  # 중지
        @actor.set_distribution_info(@prev_info)
        return_scene
      when 2  # 캔슬
        # 파라미터 윈도우로 전환해
        @confirm_window.active = false
        @confirm_window.close
        @confirm_help_window.close
        @parameter_window.active = true
      end
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_File
#==============================================================================

class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # ● 세이브 데이터의 읽기
  #     file : 읽기용 파일 오브젝트 (오픈이 끝난 상태)
  #--------------------------------------------------------------------------
  alias read_save_data_KGC_DistributeParameter read_save_data
  def read_save_data(file)
    read_save_data_KGC_DistributeParameter(file)

    KGC::Commands.check_distribution_values
    Graphics.frame_reset
  end
end