################################################################################
#                                                                              #
# DEST21C : 파라미터변화에 따른 스테이트 자동 추가 / 해제 스크립트 V0.8        #
# DEST21C : 파라미터제한수치 설정 스크립트 V1.0                                #
#                                                                              #
# 버그보고 및 리퀘스트 : dest21c@nate.com                                      #
#                                                                              #
# 추후예정 : 현재 HP나 MP가 MAXHP나 MAXMP의 일정 %일때 스테이트 자동 추가/해제 #
#                                                                              #
################################################################################
=begin

@ 주의사항
 - Game_Battler 클래스의 일부 항목을 재정의합니다.
 - 같은 개소를 재정의하는 스크립트와 경합할 우려가 있습니다.
 - 재정의한 항목
  : def maxhp_limit
  : def maxhp
  : def maxmp
  : def atk
  : def def
  : def spi
  : def agi
  : def maxhp=
  : def maxmp=
  : def atk=
  : def def=
  : def spi=
  : def agi=
  : Game_Actor 클래스의 def maxhp_limit
 
=end

module DEST21C
  module PARAMETER_STATE
    # 커스터마이즈 항목
    # ID : 조건합치시 추가할 스테이트 ID의 배열 ([1, 2, 3번째...])
    # CON1 : 계산의 조건 파라미터 수치([1, 2, 3번째...])
    # CON2 : CON1초과이면 0, 이하이면 1 (예: [0, 1, 0...])
    # CON3 : 파라미터종별
    #   (1 : STR / 2 : DEF / 3 : SPI / 4 : AGI / 5 : MAXHP / 6 : MAXMP)
    #   ([1, 2, 3번째...])
    #
    # 예시) MAXHP가 50이하일 때 30번 스테이트 추가 / SPI가 100초과일때 10번 추가
    # STATE_ID = [30, 10]
    # STATE_CON1 = [50, 100]
    # STATE_CON2 = [1, 0]
    # STATE_CON3 = [5, 3]
    STATE_ID = [20, 21, 22, 23]
    STATE_CON1 = [50, 50, 50, 50]
    STATE_CON2 = [0, 1, 0, 1]
    STATE_CON3 = [1, 2, 3, 4]
  end
  module PARAMETER_LIMIT
    # 커스터마이즈 항목
    # MAXHP : MAXHP의 한계치
    # MAXMP : MAXMP의 한계치
    # ATK : ATK의 한계치
    # DEF : DEF의 한계치
    # SPI : SPI의 한계치
    # AGI : AGI의 한계치
    MAXHP = 999
    MAXMP = 999
    ATK = 999
    DEF = 999
    SPI = 999
    AGI = 999
  end
end

class Game_Battler
  STATEID_LIST = DEST21C::PARAMETER_STATE::STATE_ID
  STATECON1_LIST = DEST21C::PARAMETER_STATE::STATE_CON1
  STATECON2_LIST = DEST21C::PARAMETER_STATE::STATE_CON2
  STATECON3_LIST = DEST21C::PARAMETER_STATE::STATE_CON3
  # 각종 파라미터를 읽을 시 스테이트의 추가/해제 판정
  def atk
    # 통상 처리의 실행
    n = [[base_atk + @atk_plus, 1].max, DEST21C::PARAMETER_LIMIT::ATK].min
    for state in states do n *= state.atk_rate / 100.0 end
    n = [[Integer(n), 1].max, DEST21C::PARAMETER_LIMIT::ATKLIMIT].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 1
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def
   
  def def
    # 통상 처리의 실행
    n = [[base_def + @def_plus, 1].max, DEST21C::PARAMETER_LIMIT::DEF].min
    for state in states do n *= state.def_rate / 100.0 end
    n = [[Integer(n), 1].max, DEST21C::PARAMETER_LIMIT::DEF].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 2
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def
 
  def spi
    # 통상 처리의 실행
    n = [[base_spi + @spi_plus, 1].max, DEST21C::PARAMETER_LIMIT::SPI].min
    for state in states do n *= state.spi_rate / 100.0 end
    n = [[Integer(n), 1].max, DEST21C::PARAMETER_LIMIT::SPI].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 3
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def
 
  def agi
    # 통상 처리의 실행
    n = [[base_agi + @agi_plus, 1].max, DEST21C::PARAMETER_LIMIT::AGI].min
    for state in states do n *= state.agi_rate / 100.0 end
    n = [[Integer(n), 1].max, DEST21C::PARAMETER_LIMIT::AGI].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 4
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def

  def maxhp_limit
    return DEST21C::PARAMETER_LIMIT::MAXHP
  end
 
  def maxhp
    # 통상 처리의 실행
    n = [[base_maxhp + @maxhp_plus, 1].max, maxhp_limit].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 5
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def
 
  def maxmp
    # 통상 처리의 실행
    n = [[base_maxmp + @maxmp_plus, 0].max, DEST21C::PARAMETER_LIMIT::MAXMP].min
    # 조건의 파라미터 종별을 검색한다.
    for s in 0...STATECON3_LIST.size
      if STATECON3_LIST[s] == 6
        # 수치 초과의 조건이라면
        if STATECON2_LIST[s] == 0
          n_id = STATEID_LIST[s]
          if n > STATECON1_LIST[s]
            add_state(n_id)
          elsif n <= STATECON1_LIST[s]
            remove_state(n_id)
          end
        # 수치 이하의 조건이라면
        elsif STATECON2_LIST[s] == 1
          n_id = STATEID_LIST[s]
          if n <= STATECON1_LIST[s]
            add_state(n_id)
          elsif n > STATECON1_LIST[s]
            remove_state(n_id)
          end
        end
      end
    end
    return n
  end #def

  # 최대HP의 설정
  def maxhp=(new_maxhp)
    @maxhp_plus += new_maxhp - self.maxhp
    @maxhp_plus = [[@maxhp_plus, -DEST21C::PARAMETER_LIMIT::MAXHP].max, DEST21C::PARAMETER_LIMIT::MAXHP].min
    @hp = [@hp, self.maxhp].min
  end
 
  # 최대MP의 설정
  def maxmp=(new_maxmp)
    @maxmp_plus += new_maxmp - self.maxmp
    @maxmp_plus = [[@maxmp_plus, -DEST21C::PARAMETER_LIMIT::MAXMP].max, DEST21C::PARAMETER_LIMIT::MAXMP].min
    @mp = [@mp, self.maxmp].min
  end
 
  # ATK의 설정
  def atk=(new_atk)
    @atk_plus += new_atk - self.atk
    @atk_plus = [[@atk_plus, -DEST21C::PARAMETER_LIMIT::ATK].max, DEST21C::PARAMETER_LIMIT::ATK].min
  end
 
  # DEF의 설정
  def def=(new_def)
    @def_plus += new_def - self.def
    @def_plus = [[@def_plus, -DEST21C::PARAMETER_LIMIT::DEF].max, DEST21C::PARAMETER_LIMIT::DEF].min
  end
 
  # SPI의 설정
  def spi=(new_spi)
    @spi_plus += new_spi - self.spi
    @spi_plus = [[@spi_plus, -DEST21C::PARAMETER_LIMIT::SPI].max, DEST21C::PARAMETER_LIMIT::SPI].min
  end
 
  # AGI의 설정
  def agi=(new_agi)
    @agi_plus += new_agi - self.agi
    @agi_plus = [[@agi_plus, -DEST21C::PARAMETER_LIMIT::AGI].max, DEST21C::PARAMETER_LIMIT::AGI].min
  end
 
end #class Game_Battler

# 상기 실행만으로는 곧바로 적용되지 않으므로 파라미터를 불러들여 처리한다.
# Scene_Menu 클래스에서 각종 파라미터를 불러들인다.
class Scene_Menu < Scene_Base
  alias dest21c_parameter_state_start start
  def start
    parameters_load_module
    dest21c_parameter_state_start
  end
end

# Scene_Item 클래스에서 각종 파라미터를 불러들인다.
class Scene_Item < Scene_Base
  alias dest21c_parameter_state_update update
  def update
    parameters_load_module
    dest21c_parameter_state_update
  end
end

# Scene_Skill 클래스에서 각종 파라미터를 불러들인다.
class Scene_Skill < Scene_Base
  alias dest21c_parameter_state_update update
  def update
    parameters_load_module
    dest21c_parameter_state_update
  end
end

# Scene_Status 클래스에서 각종 파라미터를 불러들인다.
class Scene_Status < Scene_Base
  alias dest21c_parameter_state_start start
  def start
    parameters_load_module
    dest21c_parameter_state_start
  end
end

# Scene_Equip 클래스에서 각종 파라미터를 불러들인다.
class Scene_Equip < Scene_Base
  alias dest21c_parameter_state_update update
  def update
    parameters_load_module
    dest21c_parameter_state_update
  end
end

# Scene_Battle 클래스에서 각종 파라미터를 불러들인다.
class Scene_Battle < Scene_Base
  alias dest21c_parameter_state_update update

  def start
    parameters_load_module
    dest21c_parameter_state_update
  end
end

# 액터의 최대HP한계치를 설정한다.
class Game_Actor < Game_Battler
  def maxhp_limit
    return super()
  end
end

# 각종 파라미터를 불러들이는 모듈
def parameters_load_module
  $game_party.members.each{|actor|
    a = actor.atk}
  $game_party.members.each{|actor|
    a = actor.def}
  $game_party.members.each{|actor|
    a = actor.spi}
  $game_party.members.each{|actor|
    a = actor.agi}
  $game_party.members.each{|actor|
    a = actor.maxhp}
  $game_party.members.each{|actor|
    a = actor.maxmp}
end

사용시에는 가능하시면 리플, 쪽지나 메일로 사용보고 부탁드립니다.