#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/   â—†     Attribute Point Stat Distribution - KGC_DistributeParameter  â—† VX â—†
#_/   â—‡                      Last Update: 2008/09/13                          â—‡
#_/   â—†                    Translation by Mr. Anonymous                       â—†
#_/   â—†                  Extended Annotation by Touchfuzzy                    â—†
#_/   â—†             Extended Updates by MrAnonymous & Touchfuzzy              â—†
#_/   â—† KGC Site:                                                             â—†
#_/   â—† http://f44.aaa.livedoor.jp/~ytomy/                                    â—†
#_/   â—† Translator's Blog:                                                    â—†
#_/   â—† http://mraprojects.wordpress.com                                      â—†
#_/-----------------------------------------------------------------------------
#_/  This script gives you the ability to completely change the way actors'
#_/ attributes are gained. This system allows for the player to distribute stat
#_/ points to actors which are gained upon level up.
#_/=============================================================================
#_/                       â—† Script Commands â—†
#_/  These commands are used in "Script" function in the third page of event
#_/   commands under "Advanced".
#_/
#_/ * gain_rp(ActorID, Value)
#_/    Increases the MaxRP of a given actor.
#_/
#_/ * reset_distributed_count(ActorID)
#_/    Resets the distributed RP of a given actor.
#_/
#_/ * call_distribute_parameter(ActorID)
#_/    Calls the Distribute Parameter screen for a given actor.
#_/
#_/=============================================================================
#_/ Install: Insert below KGC_ExtendedEquipScene and KGC_CustomMenuCommand.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

#==============================================================================#
#                           ★ Customization ★                                  #
#==============================================================================#

module KGC
  module DistributeParameter
  #                      â—† Distribution Tables â—†
  # Here you may customize the costs and increase rates of specific parameters.
  # The order in which these costs and increase rates are set are as follows:
  #                     [IPC, IPSG, MAP, PCI, PSGI]
  #                                Key:
  # IPC = Initial Point Cost. This is how many AP it cost to buy the first
  #       point of this parameter.
  #
  # IPSG = Initial Point Stat Growth. This is how much the stat will go up with
  #        the first point of this parameter.
  #                                              
  # MAP = Maximum Attribute Points. The maximum amount of AP that can be spent  
  #       on this stat.  You may also put a level based equation in this but
  #       remember that if you put in an equation it is IMPORTANT that you put
  #       quotation marks ("") around it and to use level in all lower case.
  #       Example: "level"
  #
  # PCI = Point Cost Increase.  For every AP spent in this parameter the cost
  #       of this parameter increases by this amount.
  #
  # PSGI = Point Stat Growth Increase.  For every AP spent in this parameter
  #        the number of points you gain in the stat increases by this much.
  #
  #   Also, if you completely remove a line (e.g. ":hit => [1, 1, 20, 0.7],")
  #   it will remove it from the distribution screen altogether.
  #   Very useful if your project doesn't require a specific stat.
  GAIN_PARAMETER = {
  # Parameter      IPC, IPSG,  MAP,   PCI,   PSGI
    :maxhp       => [1,   30,   30,   0.4,     2],  # Maximum HP
    :maxmp       => [1,    5,   30,   0.4,   0.5],  # Maximum MP
    :atk         => [1,    2,   30,   0.4,   0.5],  # Attack
    :def         => [1,    2,   30,   0.4,   0.5],  # Defense
    :spi         => [1,    2,   30,   0.4,   0.5],  # Spirit
    :agi         => [1,    2,   30,   0.4,   0.5],  # Agility
    :hit         => [1,    1,   20,   0.7],         # Hit Ratio (Accuracy)
    :eva         => [1,    1,   20,   0.7],         # Evasion
    :cri         => [1,    1,   20,   0.7],         # Critical
    :odds        => [1,    1,   5],           # Luck (Chance of being targetted)
  #                         â—† AP Gain Rate â—†
  # Added by Touchfuzzy.
  #  I added this in to the GAIN_PARAMETER tables so that you can use seperate
  #  equations for different characters and classes.
  #  This is the equation that determines your total AP gained every level.
  #  (Character Level to the 0.25th power + 2) * Level
  #  This causes you to start at 3 points per level and increase slightly over
  #  time.
  #  As an example if you wish to gain a static 3 points per level write it as
  #  :maxrpexp = "level * 3"    
    :maxrpexp    => ["(level ** 0.25 + 2.0) * level"],  # Max AP
  }  # <- Do not remove!

  #              â—† Individual Actor Gain Parameter Tables â—†
  #  You may choose to manually specify an individual actor's gain parameters.
  #  To do so, use the same format as above GAIN_PARAMETER table but instead
  #  use PERSONAL_GAIN_PARAMETER [n] (Where n = Actor ID)
  #  Any parameter you do not set in this table will instead draw from the
  #  GAIN_PARAMETER chart.
  #
  #  Example:
  PERSONAL_GAIN_PARAMETER[1] = {
    :maxhp => [2, 20, 50, 0.5,   5],    
    :maxmp => [1, 10, 30, 0.3, 0.5],  
    :atk   => [1,  1, 30, 0.3, 0.5],  
    :def   => [1,  2, 30, 0.4, 0.5],  
    :spi   => [1,  2, 50, 0.5, 0.8],  
    :agi   => [1,  2, 30, 0.4, 0.6],  
    :hit   => [1,  1, 20, 0.7],      
    :eva   => [1,  1, 20, 0.7],      
    :cri   => [1,  1, 20, 0.7],
    :skill_speed => [1,  1, 20, 0.5],    
    :item_speed  => [1,  1, 20, 0.5],      
    :odds        => [1,  1, 5],            
    :maxrpexp => ["(level ** 0.25 + 2.0) * level"]
   }
  #            â˜… Insert Custom Actor Gain Tables Below Here ★
  

  
  
  #            â˜… Insert Custom Actor Gain Tables Above Here ★

  #               â—† Class-Specific Gain Parameter Tables â—†
  #  You may choose to manually specify an entire class's gain parameters.
  #  To do so, use the same format as above GAIN_PARAMETER table but instead
  #  use CLASS_GAIN_PARAMETER [n] (Where n = Number of class in the database)
  #  Any parameter you do not set in this table will instead draw from the
  #  GAIN_PARAMETER chart. Also note that class gain parameters take the highest
  #  priority.
  
  #            â˜… Insert Custom Class Gain Tables Below Here ★

  
  
  
  #            â˜… Insert Custom Class Gain Tables Above Here ★

  # â—† AP = Attribute Points. These settings are for the AP Distrubution Screen.
  #  VOCAB_RP appears at the top of the column which lists the AP cost of
  #  the parameter
  VOCAB_RP   = "Cost"
  # VOCAB_RP_A appears next to where it lists your current and total AP.
  VOCAB_RP_A = "AP"

  #                     â—† Parameter Labels â—†
  #  Allows you to change the text of Hit Ratio, Evasion, Critical, Skill
  #   Speed, Item Speed, and Odds (luck) on the distribution screen.
  VOCAB_PARAM = {
    :hit         => "ACU",  # Hit Ratio (Accuracy)
    :eva         => "EVA",  # Evasion
    :cri         => "CRI",  # Critical
    :skill_speed => "SSD",  # Skill Speed
    :item_speed  => "ISD",  # Item Speed
    :odds        => "LCK",  # Odds (Luck)
  }  # <- Do not remove!
  
  #                       â—† Caption Text â—†  
  # These fields affect the text at the top of the distribution screen.
  # Attribute name label.
  AT_CAPTION = "Attribute"
  # AP cost/rate label.
  RT_CAPTION = "Rate"
  # Current AP ppent on given attribute label.
  SP_CAPTION = "Spent"
  # Current status (right window) label.
  CS_CAPTION = "Current Status"
  
  #                      â—† Help Window Text â—†  
  #  Text of the menu title for the AP Distribution Screen.
  DISTRIBUTE_SCENE_CAPTION = "Stat Distribution - Press L or R to switch characters."
  
  #                      â—† AP Gauge Colors â—†
  #  Allows you to change the color of the guages that appear under the stats
  #   side bar. The color can also be determined by a numerical expression.
  #  Example: GAUGE_START_COLOR = Color.new(255, 0, 0)  <- This is red.
  #  This is the fill color for the early phase of the guage.
  GAUGE_START_COLOR = 28
  #  This is the fill color for the late phase of the guage. (When full)
  GAUGE_END_COLOR   = 29

  #                  â—† Menu Command Button & Text â—†
  #  When USE_MENU_DISTRIBUTE_PARAMETER_COMMAND = true,
  #  the AP Distribution System is added to the menu under "Quit Game".
  #  When false, it does not. (Obviously)
  USE_MENU_DISTRIBUTE_PARAMETER_COMMAND = false
  #  Allows you to change the text for this button on the main command menu.
  VOCAB_MENU_DISTRIBUTE_PARAMETER       = "Level Up"

  #                   â—† Parameter Re-distribution â—†
  #  This affects whether the player can delevel the parameters that have
  #  been increased.
  #  true  : Allows the player to reassign AP.
  #  false : Prevents the player from unassigning AP if set to false.
  ENABLE_REVERSE_DISTRIBUTE = false
  
  #                     â—† AP in Status Window â—†
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the AP display on the status
  #   screen.
  SHOW_STATUS_RP = true
  #  This toggle allows you to adjust the position of the AP display on the
  #   status screen. (If SHOW_STATUS_RP = true)
  #  0. Below Actor's Face Image
  #  1. Below Actor's Parameters
  SHOW_STATUS_RP_POS = 1
  
  #                â—† Extra Parameters in Status Window â—†
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the parameters for accuracy,
  #   evasion, and critical below the regular paramaters (STR, DEF, SPI, AGI)
  SHOW_STATUS_EX_PARAMS = true
  
  #        â—† Call DistributeParameter From Actor Status Window â—†
  # Added by Mr. Anonymous.
  #  This allows you to change what key/button is pressed on the status window
  #   to shift to the DistributeParameter window.
  #  When set to nil, this is disabled. ( CALL_DISTPARAMKEY = Input::nil )
  CALL_DISTPARAMKEY = Input::X   # On the keyboard, button X is the A key.
  
  #                       â—† Show Actor Graphic â—†
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the actor sprite in the Distribute
  #   Parameter window next to the actor name.
  #  true = Show the sprite.
  #  false = Do not show.
  SHOW_SPRITE = true  
end
end

#=============================================================================#
#                          â˜… End Customization ★                              #
#=============================================================================#

#=================================================#
#                    IMPORT                       #
#=================================================#

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

#=================================================#

module KGC::DistributeParameter
  # Set up parameter array
  PARAMS = [:maxhp, :maxmp, :atk, :def, :spi, :agi, :hit, :eva, :cri,
    :skill_speed, :odds]
end

#=================================================#

#==============================================================================
# â–  Vocab
#==============================================================================

module Vocab
  def self.hit
    return KGC::DistributeParameter::VOCAB_PARAM[:hit]
    return $data_system.terms.hit    # Added 4/1/08
  end

  def self.eva
    return KGC::DistributeParameter::VOCAB_PARAM[:eva]
    return $data_system.terms.eva    # Added 4/1/08
  end

  def self.cri
    return KGC::DistributeParameter::VOCAB_PARAM[:cri]
    return $data_system.terms.cri    # Added 4/1/08
  end

  def self.skill_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:skill_speed]
    return $data_system.terms.skill_speed    # Added 9/14/08
  end

  def self.item_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:item_speed]
  end

  def self.odds
    return KGC::DistributeParameter::VOCAB_PARAM[:odds]
    return $data_system.terms.odds    # Added 9/14/08
  end

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

  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

#=================================================#
#             INCLUDE COMMANDS                    #
#=================================================#
#    Include KGC::Commands in Game_Interpreter    #
#=================================================#

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
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
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #     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
    result = KGC::DistributeParameter::GAIN_PARAMETER
    # アクター固有
    list = KGC::DistributeParameter::PERSONAL_GAIN_PARAMETER[self.id]
    result = result.merge(list) if list != nil
    # è�·æ¥­å›ºæœ‰
    list = KGC::DistributeParameter::CLASS_GAIN_PARAMETER[self.class_id]
    result = result.merge(list) if list != nil

    return result
  end
  #--------------------------------------------------------------------------
  # â—‹ å�„種修正値を計算
  #--------------------------------------------------------------------------
  def calc_distribution_values
    @rp_cost = 0
    @distributed_param = {}
    gain_parameter_list.each { |k, v|
      next if v == nil
      cost = 0
      param = 0
      distributed_count(k).times { |i|
        cost_plus   = v[0]
        cost_plus  += v[3] * i if v[3] != nil
        param_plus  = v[1]
        param_plus += v[4] * i if v[4] != nil
        cost  += Integer(cost_plus)
        param += Integer(param_plus)
      }
      @rp_cost += [cost, 0].max
      @distributed_param[k] = 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 ã�®å�–å¾— - Method rewritten by Touchfuzzy
  #--------------------------------------------------------------------------
  def maxrp
    gain = gain_parameter_list[:maxrpexp]
    n = Integer(eval(gain[0]))
    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 : 振り分ã�‘先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  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 : 振り分ã�‘先パラメータ (Symbol)
  #     value : 増減é‡�
  #--------------------------------------------------------------------------
  def gain_distributed_count(param, value = 1)
    n = distributed_count(param)
    @distributed_count[param] += value if n.is_a?(Integer)
  end
  #--------------------------------------------------------------------------
  # â—‹ RP 振り分ã�‘ã�«ã‚ˆã‚‹æˆ�長効果é�©ç”¨
  #     param   : 振り分ã�‘先パラメータ (Symbol)
  #     reverse : 逆加算ã�®ã�¨ã��ã�¯ true
  #--------------------------------------------------------------------------
  def rp_growth_effect(param, reverse = false)
    gain = gain_parameter_list[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 : 振り分ã�‘先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def can_distribute?(param)
    gain = gain_parameter_list[param]
    return false if gain == nil                          # 無効ã�ªãƒ‘ラメータ
    return false if self.rp < distribute_cost(param)     # RP ä¸�足
    return false if gain[2] <= distributed_count(param)  # 回数上é™�

    return true
  end
  #--------------------------------------------------------------------------
  # â—‹ パラメータ振り分ã�‘コスト計算
  #     param : 振り分ã�‘先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def distribute_cost(param)
    gain = gain_parameter_list[param]
    return 0 if gain == nil  # 無効ã�ªãƒ‘ラメータ

    n = gain[0]
    if gain[3] != nil
      count = [distributed_count(param), gain[2] - 1].min
      n += gain[3] * count
    end
    return [Integer(n), 0].max
  end
  #--------------------------------------------------------------------------
  # â—‹ パラメータ振り分ã�‘時ã�®å¢—加é‡�計算
  #     param : 振り分ã�‘先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def distribute_gain(param)
    gain = gain_parameter_list[param]
    return 0 if gain == nil  # 無効ã�ªãƒ‘ラメータ

    n = gain[1]
    if gain[4] != nil
      count = [distributed_count(param), gain[2] - 1].min
      n += gain[4] * count
    end
    return Integer(n)
  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_list[param]
    return if gain == nil
    gw = width * actor.distributed_count(param) / [gain[2], 1].max
    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
  #==========================================================================
===
  #   Added by Mr. Anonymous ( 4/1/08 )
  # Sets up the initial parameters and the entended/extra parameters.
  #==========================================================================
===
  if KGC::DistributeParameter::SHOW_STATUS_EX_PARAMS
    alias draw_actor_parameter_KGC_DistributeParameter draw_actor_parameter
    def draw_actor_parameter(actor, x, y, type)
      draw_actor_parameter_KGC_DistributeParameter(actor, x, y, type)
      case type
        when 4
          parameter_name = Vocab::hit
          parameter_value = actor.hit
        when 5
          parameter_name = Vocab::eva
          parameter_value = actor.eva
        when 6
          parameter_name = Vocab::cri
          parameter_value = actor.cri
        when 7
          parameter_name = Vocab::odds
          parameter_value = actor.odds
       end
       self.contents.font.color = system_color
       self.contents.draw_text(x, y, 120, WLH, parameter_name)
       self.contents.font.color = normal_color
       self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2)
    end
  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_Status
#==============================================================================
# Added by Mr. Anonymous  ( 4/1/08 )
# Checks SHOW_STATUS_RP's value, if true RP is added to Status Window.
#==============================================================================
if KGC::DistributeParameter::SHOW_STATUS_RP
  class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  # â—� Draw RP in Status Window
  #     x : Width X - 128 (beneath actor face)
  #     y : Hight Y (On row + Window_Status Definition)
  #--------------------------------------------------------------------------
    alias draw_basic_info_KGC_DistributeParameter draw_basic_info
    def draw_basic_info(x, y)
      draw_basic_info_KGC_DistributeParameter(x, y)
      # Checks SHOW_STATUS_RP_POS, if 0, RP is shown beneath face of actor.
      if KGC::DistributeParameter::SHOW_STATUS_RP_POS == 0
        draw_actor_rp(@actor, x - 129, y + WLH * 4)
      end
      # If 1, RP is shown under parameters. (Centered)
      if KGC::DistributeParameter::SHOW_STATUS_RP_POS == 1
        draw_actor_rp(@actor, x - 80, y + WLH * 14 - 6)
      end
    end
    #------------------------------------------------------------------------
    # â—� Draw Extra (Normally Hidden) Parameters in Status Window
    #     x : Width X - 128 (beneath actor face)
    #     y : Hight Y (On row + Window_Status Definition)
    # Added by Mr. Anonymous  ( 4/1/08 )
    #-------------------------------------------------------------------------
    alias draw_parameters_KCG_DistributeParameter draw_parameters
    def draw_parameters(x, y)
       draw_parameters_KCG_DistributeParameter(x, y)
       if KGC::DistributeParameter::SHOW_STATUS_EX_PARAMS
         draw_actor_parameter(@actor, x, y + WLH * 4, 4)
         draw_actor_parameter(@actor, x, y + WLH * 5, 5)
         draw_actor_parameter(@actor, x, y + WLH * 6, 6)
         draw_actor_parameter(@actor, x, y + WLH * 7, 7)
       end
    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, 32, 0)
    draw_actor_level(@actor, 264, 0)
    draw_actor_rp(@actor, 372, 0)
    # Include actor class
    # Added by Mr. Anonymous  ( 4/1/08 )
    draw_actor_class(@actor, 152, 0)
     # Method for displaying actor's sprite
     # Added by Mr. Anonymous  ( 4/1/08 )
    if KGC::DistributeParameter::SHOW_SPRITE
       draw_actor_graphic(@actor, 14, 31)
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_DistributeParameterList
#------------------------------------------------------------------------------
#   振り分ã�‘ç”»é�¢ã�§ã€�æˆ�é•·ã�•ã�›ã‚‹ãƒ‘ラメータをé�¸æŠžã�™ã‚‹ã‚¦ã‚£ãƒ³ï¿
½
�ウ��。
#==============================================================================

class Window_DistributeParameterList < Window_Selectable
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #     actor : アクター
  #--------------------------------------------------------------------------
  def initialize(actor)
    off_h = (WLH + 32) * 2
    super(0, off_h, Graphics.width / 2 + 80, Graphics.height - off_h)
    @actor = actor
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # â—‹ é�¸æŠžä¸­ã�®ãƒ‘ラメータã�® Symbol ã‚’å�–å¾—
  #--------------------------------------------------------------------------
  def parameter_symbol
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    gain_params = @actor.gain_parameter_list
    KGC::DistributeParameter::PARAMS.each { |param|
      next if gain_params[param] == nil
      @data << param
    }
    @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
  #--------------------------------------------------------------------------
  # â—� 1 ページã�«è¡¨ç¤ºã�§ã��る行数ã�®å�–å¾—
  #--------------------------------------------------------------------------
  def page_row_max
    return super - 1
  end
  #--------------------------------------------------------------------------
  # â—� 項目をæ��ç”»ã�™ã‚‹çŸ©å½¢ã�®å�–å¾—
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super(index)
    rect.y += WLH
    return rect
  end
  #--------------------------------------------------------------------------
  # â—‹ 見出ã�—ã�®æ��ç”»
  #--------------------------------------------------------------------------
  def draw_caption
    self.contents.font.color = system_color
  # This is shown at the top of the column that lists the stats.
    self.contents.draw_text(  4, 0, 96, WLH, KGC::DistributeParameter::AT_CAPTION)
    self.contents.draw_text(120, 0, 40, WLH, Vocab.rp, 2)
  # This is shown at the top of the column that lists the number of stat points
  #   you will gain from buying the next point of the parameter.
    self.contents.draw_text(170, 0, 60, WLH, KGC::DistributeParameter::RT_CAPTION, 2)
  # This is shown at the top of the column that lists the current and max
  #   points you have in each parameter.
    self.contents.draw_text(240, 0, 80, WLH, KGC::DistributeParameter::SP_CAPTION, 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 座標
  #     type    : 能力値ã�®ç¨®é¡ž
  #     enabled : 有効フラグ
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type, enabled)
    case type
    when :maxhp
      name  = Vocab.hp
    when :maxmp
      name  = Vocab.mp
    when :atk
      name  = Vocab.atk
    when :def
      name  = Vocab.def
    when :spi
      name  = Vocab.spi
    when :agi
      name  = Vocab.agi
    when :hit
      name  = Vocab.hit
    when :eva
      name  = Vocab.eva
    when :cri
      name  = Vocab.cri
    when :skill_speed
      name  = Vocab.skill_speed
    when :item_speed
      name  = Vocab.item_speed
    when :odds
      name  = Vocab.odds
    else
      return
    end

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

    gain = @actor.gain_parameter_list[type]
    value = @actor.distribute_cost(type)
    self.contents.draw_text(x + 120, y, 40, WLH, value, 2)
    value = sprintf("%+d", @actor.distribute_gain(type))
    self.contents.draw_text(x + 190, y, 40, WLH, value, 2)
    value = sprintf("%3d/%3d", @actor.distributed_count(type), gain[2])
    self.contents.draw_text(x + 236, 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 = Graphics.width / 2 + 80
    off_h = (WLH + 32) * 2
    super(dx, off_h, Graphics.width - dx, Graphics.height - off_h)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    original_height = self.height
    self.height = WLH * (existing_params.size + 1) + 32
    create_contents
    self.height = original_height

    self.contents.font.color = system_color
    # This allows you to change the text that appears on top of the right panel
    #  which contains current parameter changes.
    self.contents.draw_text(0, 0, width - 32, WLH, KGC::DistributeParameter::CS_CAPTION, 1)
    self.contents.font.color = normal_color
    dy = WLH
    existing_params.each { |param|
      draw_parameter(0, dy, param)
      dy += WLH
    }
  end
  #--------------------------------------------------------------------------
  # â—‹ 存在ã�™ã‚‹ãƒ‘ラメータã�®ä¸€è¦§
  #--------------------------------------------------------------------------
  def existing_params
    result = []
    gain_params = @actor.gain_parameter_list
    KGC::DistributeParameter::PARAMS.each { |param|
      next if gain_params[param] == nil
      result << param
    }
    return result
  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
    draw_actor_distribute_gauge(@actor, type, x + 106, y, 48)
    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)
  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]
    create_windows
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウ作æˆ�
  #--------------------------------------------------------------------------
  def create_windows
    @help_window = Window_Help.new
    @help_window.set_text(KGC::DistributeParameter::DISTRIBUTE_SCENE_CAPTION)
    dy = @help_window.height
    @actor_window = Window_DistributeParameterActor.new(0, dy, @actor)
    @parameter_window = Window_DistributeParameterList.new(@actor)
    @status_window = Window_DistributeParameterStatus.new(@actor)
  end
  #--------------------------------------------------------------------------
  # â—� 終了処ç�†
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @help_window.dispose
    @actor_window.dispose
    @parameter_window.dispose
    @status_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
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウ更新
  #--------------------------------------------------------------------------
  def update_window
    @help_window.update
    @actor_window.update
    @parameter_window.update
    @status_window.update
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウå†�æ��ç”»
  #--------------------------------------------------------------------------
  def refresh_window
    @actor_window.refresh
    @parameter_window.refresh
    @status_window.refresh
    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
    @status_window.oy = @parameter_window.oy

    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif input_growth?
      # 加算
      param = @parameter_window.parameter_symbol
      unless @actor.can_distribute?(param)
        Sound.play_buzzer
        return
      end
      Input.repeat?(Input::C) ? Sound.play_decision : Sound.play_cursor
      @actor.rp_growth_effect(param)
      refresh_window
    elsif input_reverse_growth?
      # 減算
      param = @parameter_window.parameter_symbol
      if @actor.distributed_count(param) == 0
        Sound.play_buzzer
        return
      end
      Input.repeat?(Input::A) ? Sound.play_decision : 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
  #--------------------------------------------------------------------------
  # â—‹ 加算入力
  #--------------------------------------------------------------------------
  def input_growth?
    if KGC::DistributeParameter::ENABLE_REVERSE_DISTRIBUTE
      return Input.repeat?(Input::C) || Input.repeat?(Input::RIGHT)
    else
      return Input.trigger?(Input::C)
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 減算入力
  #--------------------------------------------------------------------------
  def input_reverse_growth?
    if KGC::DistributeParameter::ENABLE_REVERSE_DISTRIBUTE
      return Input.repeat?(Input::A) || Input.repeat?(Input::LEFT)
    else
      return false
    end
  end
end

#==============================================================================
# â–  Scene_Status
#==============================================================================
# Added by Mr. Anonymous
#==============================================================================
class Scene_Status < Scene_Base
  #--------------------------------------------------------------------------
  # â—� Update Actor
  #--------------------------------------------------------------------------
    alias update_KGC_DistributeParameter update
    def update
      if KGC::DistributeParameter::CALL_DISTPARAMKEY != nil &&
         Input.trigger?(KGC::DistributeParameter::CALL_DISTPARAMKEY)
         Sound.play_decision
         $scene = Scene_DistributeParameter.new(@actor_index)
      end
     update_KGC_DistributeParameter
   end
end

#==============================================================================
# â–  Scene_File
#==============================================================================

class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # â—� Read Saved Data
  #     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