［설정］
우선, 능력 가격인상승이 발생하는 퍼센티지를 결정합니다.
값은 각자의 게임 밸런스에 맞추어 조절해 주세요.
배열은, 왼쪽에서 순서에[최대HP/최대SP/완력/손재주가 있음/민첩함/마력]이 되고 있습니다.

전투 종료시에 모든 행동의 상승률의 평균치로부터, 능력 상승이 일어날까 결정합니다.
합계는 아니고 평균치이므로, 주의해 주세요.

예를 들어, 다음과 같이 상승률을 설정했다고 합니다.

　　ACT_ATK = [10, 0, 10, 5, 5, 0]　　　# 통상 공격
　　ACT_GUARD = [20, 0, 0, 0, 0, 0]　　　# 방어

이 상승률로, 공격 4회＆방어 1회를 실시했을 때,
전투 종료시에 각 능력치가 올라가는 확률은

　최대HP：12%　최대SP：0%　완력：8%
　손재주가 있음：4%　민첩함：4%　마력：0%

가 됩니다.
(이것을 기본치로서 적의 힘에 따르고 보정이 들어가는)

상승하는 수치는, 각 스테이터스 마다 최대치와 최소치를 설정해,
그 범위내에서 랜덤으로 상승합니다.




[스크립트]

#==============================================================================
#　＋＋　전투 종료시에 스테이터스 UP　ver. 1.40　＋＋
#　　Script by 파라개
#　　http://para.j-mx.com/
#------------------------------------------------------------------------------
# 전투시의 행동에 의해, 배틀 종료시에 스테이터스가 올라갑니다.
#------------------------------------------------------------------------------
#［설치상의 주의］
# 액티브 타임 배틀과 병용 할 때는, 이 스크립트를 아래에 두어 주세요.
#==============================================================================

module PARA_STSUP
 
  # 각 행동시에 능력치가 올라가는 확률
  # (전투 종료시에 모든 행동의 평균치로 계산하는)
  # [최대HP/최대SP/완력/손재주가 있음/민첩함/마력]
  ACT_ATK = [10, 0, 10, 5, 5, 0]      # 통상 공격
  ACT_SKILL = [5, 10, 5, 5, 5, 5]    # 스킬
  ACT_GUARD = [20, 0, 0, 0, 0, 0]    # 방어
  ACT_ITEM = [5, 5, 5, 5, 5, 5]      # 아이템
  ACT_NONE = [0, 0, 0, 0, 0, 0]      # 커멘드미입력 또는 행동 불능

  # 무기 속성으로 통상 공격의 성장률을 변화
  # (서식은 「 "속성명"=>성장률 」.맨 마지막 줄은 「 } 」으로 닫는다)
  ATK_ELEMENTS = {  "검" => [10, 0, 10, 5, 5, 0],
                    "창" => [10, 0, 10, 5, 5, 0],
                    "도끼" => [10, 0, 20, 0, 0, 0]}

  # 스킬의 속성으로 성장률을 변화
  SKILL_ELEMENTS = {  "검" => [5, 10, 10, 5, 5, 0],
                      "창" => [5, 10, 5, 5, 10, 0],
                      "도끼" => [10, 10, 20, 0, 0, 0],
                      "흑마법" => [0, 15, 0, 5, 0, 15],
                      "신성 마법" => [0, 15, 0, 0, 5, 15]}

  # 상승치 [최소치,최대치]
  # [최대HP/최대SP/완력/손재주가 있음/민첩함/마력]
  UP_POINT = [ [5,20], [5,20], [1,5], [1,5], [1,5], [1,5] ]
 
  # 능력치 한계
  # [최대HP/최대SP/완력/손재주가 있음/민첩함/마력]
  LIMIT = [ 999999, 9999, 999, 999, 999, 999 ]

  # 스테이터스 업을 실시하지 않는 액터의ID
  #(액터ID를 콤마로 단락지어 기술. 예：[ 0, 2, 3 ] )
  EXC_ACTOR = []

  # 스테이터스 업 결과의 표시순서( 0:액터마다 / 1:능력치 마다 )
  THREAD_TYPE = 0

  # 스테이터스 상승 윈도우를 표시할까( true / false )
  VIEW_VISIBLE = true
  # 스테이터스 상승 윈도우의 서식
  # {name} :액터명
  # {param} :파라미터
  # {point} :상승치
  VIEW_TEXT = "{name}의 것{param}이{point}포인트 업"
  # 스테이터스 상승 윈도우의 표시 시간
  VIEW_TIME = 40
  # 스테이터스 상승 윈도우를 표시하지 않을 때의 애니메이션 표시 간격
  VIEW_ANM_TIME = 8
 
  # 적과의 힘에 차이가 있을 때, 성장률에 영향을 줄까( true / false )
  # (보정율은 「적의 능력치÷액터의 능력치」의 평균)
  LVEF = true
  # 능력치 업율에 대한 보정율의 적용 퍼센트
  LVEF_PER = 50
  # 상승치에 대한 보정율의 적용 퍼센트
  LVEF_POINT = 0
  # 인원수차이가 보정율에게 주는 영향(퍼센트)
  LVEF_PARTIES = 50
 
  # 스테이터스 업시에 애니메이션을 표시( true / false )
  ANM_USE = true
  # 표시하는 애니메이션의ID
  ANM_HP = 98    # 최대HP
  ANM_SP = 98    # 최대SP
  ANM_STR = 98  # 완력
  ANM_DEX = 98  # 손재주가 있음
  ANM_AGI = 98  # 민첩함
  ANM_INT = 98  # 마력
 
end

# ↑ 설정 항목 여기까지
#------------------------------------------------------------------------------

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● 프레바트르페즈 개시
  #--------------------------------------------------------------------------
  alias start_phase1_stsup start_phase1
  def start_phase1
    for actor in $game_party.actors
      # 행동 이력을 초기화
      actor.act_history = []
    end
    @stsup = []
    @now_stsup_anm = -1
    @btl_lv = 0
    enemy_sts = [0,0,0,0,0,0]
    actor_sts = [0,0,0,0,0,0]
    btl_lv = [0,0,0,0,0,0]
    # 에너미의 힘을 기록
    for enemy in $game_troop.enemies
      enemy_sts[0] += enemy.base_maxhp
      enemy_sts[1] += enemy.base_maxsp
      enemy_sts[2] += enemy.base_str
      enemy_sts[3] += enemy.base_dex
      enemy_sts[4] += enemy.base_agi
      enemy_sts[5] += enemy.base_int
    end
    # 액터의 힘을 기록
    for actor in $game_party.actors
      actor_sts[0] += actor.base_maxhp
      actor_sts[1] += actor.base_maxsp
      actor_sts[2] += actor.base_str
      actor_sts[3] += actor.base_dex
      actor_sts[4] += actor.base_agi
      actor_sts[5] += actor.base_int
    end
    # 일체 근처의 힘을 계산
    for i in 0..5
      enemy_sts[i] /= $game_troop.enemies.size.to_f
      actor_sts[i] /= $game_party.actors.size.to_f
    end
    # 적의 힘의 배율
    for i in 0..5
      btl_lv[i] = enemy_sts[i] / actor_sts[i]
      @btl_lv += btl_lv[i]
    end
    @btl_lv /= btl_lv.size
    # 인원수차이에 의한 보정
    m = $game_troop.enemies.size.to_f / $game_party.actors.size.to_f
    if m >= 1
      m = 1 + (m - 1) * PARA_STSUP::LVEF_PARTIES / 100
    else
      m = 1 - (1 - m) * PARA_STSUP::LVEF_PARTIES / 100
    end
    if @btl_lv >= 1
      @btl_lv = (@btl_lv - 1) * m + 1
    else
      @btl_lv = @btl_lv * m
    end
    start_phase1_stsup
  end
  #--------------------------------------------------------------------------
  # ● 다음의 액터의 커멘드 입력에
  #--------------------------------------------------------------------------
  alias phase3_next_actor_stsup phase3_next_actor
  def phase3_next_actor
    if @active_battler != nil
      # 액션을 행동 이력에 추가
      act_kind = @active_battler.current_action.kind
      act_basic = @active_battler.current_action.basic
      act = [act_kind,act_basic]
      if act == [0,0]  # 공격
        # 무기 속성에 의해서 성장률을 변경
        if @active_battler.element_set.size != 0
          for element_id in @active_battler.element_set
            element_name = $data_system.elements[element_id]
            if PARA_STSUP::ATK_ELEMENTS.include?(element_name)
              per = PARA_STSUP::ATK_ELEMENTS[element_name]
            end
          end
        end
        if per == nil
          per = PARA_STSUP::ACT_ATK
        end
      elsif act == [0,1]  # 방어
        per = PARA_STSUP::ACT_GUARD
      elsif act == [1,3] or act == [1,0]  # 스킬
        # 스킬 속성에 의해서 성장률을 변경
        skill_id = @active_battler.current_action.skill_id
        skill_elements = $data_skills[skill_id].element_set
        if skill_elements.size != 0
          for element_id in skill_elements
            element_name = $data_system.elements[element_id]
            if PARA_STSUP::SKILL_ELEMENTS.include?(element_name)
              per = PARA_STSUP::SKILL_ELEMENTS[element_name]
            end
          end
        end
        if per == nil
          per = PARA_STSUP::ACT_SKILL
        end
      elsif act == [2,3] or act == [2,0]  # 아이템
        per = PARA_STSUP::ACT_ITEM
      else
        per = PARA_STSUP::ACT_NONE
      end
      @active_battler.act_history.push(per)
    end
    phase3_next_actor_stsup
  end
  #--------------------------------------------------------------------------
  # ● 전의 액터의 커멘드 입력에
  #--------------------------------------------------------------------------
  alias phase3_prior_actor_stsup phase3_prior_actor
  def phase3_prior_actor
    phase3_prior_actor_stsup
    if @active_battler != nil
      # 행동 이력을 삭제
      @active_battler.act_history.pop
    end
  end
  #--------------------------------------------------------------------------
  # ● 애프터 배틀 국면 개시
  #--------------------------------------------------------------------------
  alias start_phase5_stsup start_phase5
  def start_phase5
    start_phase5_stsup
    # 스테이터스 업 처리
    status_up
  end
  #--------------------------------------------------------------------------
  # ● 프레임 갱신 (애프터 배틀 국면)
  #--------------------------------------------------------------------------
  alias update_phase5_stsup update_phase5
  def update_phase5
    # 스테이터스 상승 윈도우 표시 기다리는 아이템이 있는 경우
    if @stsup != nil and @stsup != []
      # C 버튼이 밀렸을 경우
      if Input.trigger?(Input::C)
        # 다음의 스테이터스 업 윈도우를 표시
        result_stsup
      end
      # 웨이트 카운트가 0 보다 큰 경우
      if @phase5_wait_count > 0
        # 웨이트 카운트를 줄이는
        @phase5_wait_count -= 1
        # 웨이트 카운트가 0 가 되었을 경우
        if @phase5_wait_count == 0
          # 다음의 스테이터스 업 윈도우를 표시
          result_stsup
        end
        return
      end
    # 스테이터스 상승 윈도우 표시중의 경우
    elsif @help_window.visible
      # C 버튼이 밀렸을 경우
      if Input.trigger?(Input::C)
        @help_window.visible = false
        @phase5_wait_count = 1
      end
      # 웨이트 카운트가 0 보다 큰 경우
      if @phase5_wait_count > 0
        # 웨이트 카운트를 줄이는
        @phase5_wait_count -= 1
        # 웨이트 카운트가 0 가 되었을 경우
        if @phase5_wait_count == 0
          @help_window.visible = false
          @phase5_wait_count = 1
        end
        return
      end
    else
      update_phase5_stsup
    end
  end
  #--------------------------------------------------------------------------
  # ○ 스테이터스 업 윈도우를 표시
  #--------------------------------------------------------------------------
  def result_stsup
    if @stsup[0] != nil and @stsup[0] != []
      # 배열의 선두로부터 값을 꺼내는
      stsup = @stsup[0]
      # 능력치의 이름을 취득
      case stsup[1]
        when 0  # 최대HP
        stsup_sts = $data_system.words.hp
        when 1  # 최대SP
        stsup_sts = $data_system.words.sp
        when 2  # 완력
        stsup_sts = $data_system.words.str
        when 3  # 손재주가 있음
        stsup_sts = $data_system.words.dex
        when 4  # 민첩함
        stsup_sts = $data_system.words.agi
        when 5  # 마력
        stsup_sts = $data_system.words.int
      end
      name = stsup[0].name
      param = stsup_sts
      point = stsup[2]
      # 표시하는 문자열을 설정
      text = PARA_STSUP::VIEW_TEXT.dup
      begin
        text[/{name}/] = "#{name}"
      rescue
      end
      begin
        text[/{param}/] = "#{param}"
      rescue
      end
      begin
        text[/{point}/] = "#{point.to_s}"
      rescue
      end
      # 헬프 윈도우에 문자열을 세트
      @help_window.set_text(text, 1)
      # 애니메이션을 표시
      if PARA_STSUP::ANM_USE
        # 애니메이션을 정리해 표시
        if PARA_STSUP::THREAD_TYPE == 1
          if @now_stsup_anm != stsup[1]
            @now_stsup_anm = stsup[1]
            actors = []
            for sts_group in @stsup
              if sts_group[1] == @now_stsup_anm
                actors.push(sts_group[0])
              end
            end
            for actor in actors
              case @now_stsup_anm
                when 0  # 최대HP
                actor.animation_id = PARA_STSUP::ANM_HP
                when 1  # 최대SP
                actor.animation_id = PARA_STSUP::ANM_SP
                when 2  # 완력
                actor.animation_id = PARA_STSUP::ANM_STR
                when 3  # 손재주가 있음
                actor.animation_id = PARA_STSUP::ANM_DEX
                when 4  # 민첩함
                actor.animation_id = PARA_STSUP::ANM_AGI
                when 5  # 마력
                actor.animation_id = PARA_STSUP::ANM_INT
              end
            end
          end
        else
          actor = stsup[0]
          case stsup[1]
            when 0  # 최대HP
            actor.animation_id = PARA_STSUP::ANM_HP
            when 1  # 최대SP
            actor.animation_id = PARA_STSUP::ANM_SP
            when 2  # 완력
            actor.animation_id = PARA_STSUP::ANM_STR
            when 3  # 손재주가 있음
            actor.animation_id = PARA_STSUP::ANM_DEX
            when 4  # 민첩함
            actor.animation_id = PARA_STSUP::ANM_AGI
            when 5  # 마력
            actor.animation_id = PARA_STSUP::ANM_INT
          end
        end
      end
      @stsup.shift
      # 헬프 윈도우를 표시
      if PARA_STSUP::VIEW_VISIBLE
        @help_window.visible = true
        @phase5_wait_count = PARA_STSUP::VIEW_TIME
      else
        @help_window.visible = false
        @phase5_wait_count = PARA_STSUP::VIEW_ANM_TIME
      end
    end
  end
  #--------------------------------------------------------------------------
  # ○ 스테이터스 업 처리
  #--------------------------------------------------------------------------
  def status_up
    for actor in $game_party.actors
      # EXP를 취득할 수 없는 스테이트시 혹은
      # 제외 액터는 처리를 스킵
      if actor.cant_get_exp? or PARA_STSUP::EXC_ACTOR.include?(actor.id)
        next
      end
      stsup_percent = [0,0,0,0,0,0]
      # 커멘드미입력이었던 경우
      if actor.act_history == []
        # 더미 커멘드를 추가
        actor.act_history.push(PARA_STSUP::ACT_NONE)
      end
      for act in actor.act_history
        # 상승 퍼센티지를 합계
        for i in 0...stsup_percent.size
          stsup_percent[i] += act[i]
        end
      end
      # 적의 힘에 의한 보정
      if PARA_STSUP::LVEF
        for i in 0..stsup_percent.size-1
          if @btl_lv >= 1
            btl_per = 1 + (@btl_lv - 1) * PARA_STSUP::LVEF_PER / 100
          else
            btl_per = 1 - (1 - @btl_lv) * PARA_STSUP::LVEF_PER / 100
          end
          stsup_percent[i] *= btl_per
        end
      end
      # 상승 퍼센티지를 산출
      for i in 0..stsup_percent.size-1
        stsup_percent[i] /= actor.act_history.size
      end
      # 각 스테이터스로 상승 판정
      for s in 0..stsup_percent.size-1
        rnd = rand(100)
        if stsup_percent[s] > rnd
          # 상승치를 결정
          up_point = PARA_STSUP::UP_POINT[s].dup
          # 적의 힘에 의한 보정
          if PARA_STSUP::LVEF
            if @btl_lv >= 1
              btl_point = 1 + (@btl_lv - 1) * PARA_STSUP::LVEF_POINT / 100
            else
              btl_point = 1 - (1 - @btl_lv) * PARA_STSUP::LVEF_POINT / 100
            end
            up_point[0] *= @btl_lv * btl_point
            up_point[1] *= @btl_lv * btl_point
          end
          # 랜더마이즈
          rnd_val = (up_point[1] - up_point[0]).floor
          rnd_pt = rand(rnd_val)
          stsup_pt = (rnd_pt + up_point[0]).floor
          # 능력치를 상승
          case s
            when 0  # 최대HP
              if actor.stsup_maxhp + stsup_pt > PARA_STSUP::LIMIT[0]
                stsup_pt = PARA_STSUP::LIMIT[0] - actor.stsup_maxhp
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_maxhp += stsup_pt
            when 1  # 최대SP
              if actor.stsup_maxsp + stsup_pt > PARA_STSUP::LIMIT[1]
                stsup_pt = PARA_STSUP::LIMIT[1] - actor.stsup_maxsp
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_maxsp += stsup_pt
            when 2  # 완력
              if actor.stsup_str + stsup_pt > PARA_STSUP::LIMIT[2]
                stsup_pt = PARA_STSUP::LIMIT[2] - actor.stsup_str
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_str += stsup_pt
            when 3  # 손재주가 있음
              if actor.stsup_dex + stsup_pt > PARA_STSUP::LIMIT[3]
                stsup_pt = PARA_STSUP::LIMIT[3] - actor.stsup_dex
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_dex += stsup_pt
            when 4  # 민첩함
              if actor.stsup_agi + stsup_pt > PARA_STSUP::LIMIT[4]
                stsup_pt = PARA_STSUP::LIMIT[4] - actor.stsup_agi
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_agi += stsup_pt
            when 5  # 마력
              if actor.stsup_int + stsup_pt > PARA_STSUP::LIMIT[5]
                stsup_pt = PARA_STSUP::LIMIT[5] - actor.stsup_int
                stsup_pt = stsup_pt < 0 ? 0 : stsup_pt
              end
              actor.stsup_int += stsup_pt
          end
          # 상승 포인트가0때는 스킵
          if stsup_pt <= 0
            next
          end
          # 배열에 추가
          @stsup.push([actor,s,stsup_pt])
        end
      end
    end
    if PARA_STSUP::THREAD_TYPE == 1 and @stsup != []
      # 능력치 마다 소트
      @stsup.sort! do |a, b|
        if a[1] > b[1]
          +1
        elsif a[1] < b[1]
          -1
        elsif a[0].index > b[0].index
          +1
        elsif a[0].index < b[0].index
          -1
        else
          a <=> b
        end
      end
    end
  end
end

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

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 공개 인스턴스 변수
  #--------------------------------------------------------------------------
  attr_accessor :act_history          # 행동 이력
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #--------------------------------------------------------------------------
  alias initialize_stsup initialize
  def initialize
    initialize_stsup
    @act_history = []
  end
end

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

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 공개 인스턴스 변수
  #--------------------------------------------------------------------------
  attr_accessor :stsup_maxhp
  attr_accessor :stsup_maxsp
  attr_accessor :stsup_str
  attr_accessor :stsup_dex
  attr_accessor :stsup_agi
  attr_accessor :stsup_int
  #--------------------------------------------------------------------------
  # ● 셋업
  #    actor_id : 액터 ID
  #--------------------------------------------------------------------------
  alias setup_stsup setup
  def setup(actor_id)
    setup_stsup(actor_id)
    @stsup_maxhp = 0
    @stsup_maxsp = 0
    @stsup_str = 0
    @stsup_dex = 0
    @stsup_agi = 0
    @stsup_int = 0
  end
  #--------------------------------------------------------------------------
  # ● 기본 MaxHP 의 취득
  #--------------------------------------------------------------------------
  alias base_maxhp_stsup base_maxhp
  def base_maxhp
    n = base_maxhp_stsup
    if @stsup_maxhp != nil
      n += @stsup_maxhp
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 MaxSP 의 취득
  #--------------------------------------------------------------------------
  alias base_maxsp_stsup base_maxsp
  def base_maxsp
    n = base_maxsp_stsup
    if @stsup_maxsp != nil
      n += @stsup_maxsp
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 완력의 취득
  #--------------------------------------------------------------------------
  alias base_str_stsup base_str
  def base_str
    n = base_str_stsup
    if @stsup_str != nil
      n += @stsup_str
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 손재주가 있음의 취득
  #--------------------------------------------------------------------------
  alias base_dex_stsup base_dex
  def base_dex
    n = base_dex_stsup
    if @stsup_dex != nil
      n += @stsup_dex
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 민첩함의 취득
  #--------------------------------------------------------------------------
  alias base_agi_stsup base_agi
  def base_agi
    n = base_agi_stsup
    if @stsup_agi != nil
      n += @stsup_agi
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ● 기본 마력의 취득
  #--------------------------------------------------------------------------
  alias base_int_stsup base_int
  def base_int
    n = base_int_stsup
    if @stsup_int != nil
      n += @stsup_int
    end
    return n
  end
end




[출처]
http://para.j-mx.com/rgss/script/sts_up.html