오우.. 상태창 4개가 되는건가여?

 오... 이쁜데요?

# ★ change BATORUREIAUTO
# SUTETOAIKON material, the use of animation, recommended

#================================================= =============================
# ■ Ziifee
#================================================= =============================

module Zii
 
 
   # ▼ rotation (a "positive" or "reverse" Cart)
   TURN = "positive"
 
   # ▼ face graphics (using "use" / if you do not use "")
   STATUS_FACE = ""
 
   # ▼ display settings ( "name" to "" to hide the name)
   STATUS_LINE = ""
 
   # ▼ △ size (VX standard size is 20)
   LINE_SIZE = 14
 
  #------------------------------------------------- -------------------------
  # ● normal rotation of judgement
  #------------------------------------------------- -------------------------
  def self.turn_normal?
    return false if TURN == "reverse"
    return true if TURN == "positive"
    return true
  end
  #------------------------------------------------- -------------------------
  # ● Battle option face Graphics judgement
  #------------------------------------------------- -------------------------
  def self.battle_face?
    return true if STATUS_FACE == ""
    return false
  end
  #------------------------------------------------- -------------------------
  # ● In the Name of judge
  #------------------------------------------------- -------------------------
  def self.line_name?
    return true if STATUS_LINE == "name"
    return false
  end
end

#==============================================================================
# �� Window_Base
#==============================================================================

class Window_Base
  #--------------------------------------------------------------------------
  # �� ���O���t�B�b�N���`�� ��
  #     opacity : �s�����x
  #--------------------------------------------------------------------------
  def draw_face(face_name, face_index, x, y, size = 96, opacity = 255)
    bitmap = Cache.face(face_name)
    rect = Rect.new(0, 0, 0, 0)
    rect.x = face_index % 4 * 96 + (96 - size) / 2
    rect.y = face_index / 4 * 96 + (96 - size) / 2
    rect.width = size
    rect.height = size
    self.contents.blt(x, y, bitmap, rect, opacity)
    bitmap.dispose
  end
  #--------------------------------------------------------------------------
  # �� �A�N�^�[�����O���t�B�b�N�`�� ��
  #     opacity : �s�����x
  #--------------------------------------------------------------------------
  def draw_actor_face(actor, x, y, size = 96, opacity = 255)
    draw_face(actor.face_name, actor.face_index, x, y, size, opacity)
  end
end

#==============================================================================
# �� Window_SpinCommand
#------------------------------------------------------------------------------
# �@���]�p�R�}���h�I�����s���E�B���h�E�����B
#==============================================================================

#==============================================================================
# �� Window_LineHelp
#------------------------------------------------------------------------------
# �@�X�L�����A�C�e���������A�A�N�^�[���X�e�[�^�X��������������E�B���h�E�����B
#==============================================================================

class Window_LineHelp < Window_Base
  #--------------------------------------------------------------------------
  # �� �I�u�W�F�N�g������
  #--------------------------------------------------------------------------
  def initialize
    super(-16, 0, 576, WLH + 32)
    self.opacity = 0
  end
  #--------------------------------------------------------------------------
  # �� �e�L�X�g����
  #     text  : �E�B���h�E���������������
  #     align : �A���C�������g (0..�������A1..���������A2..�E����)
  #--------------------------------------------------------------------------
  def set_text(text, align = 0)
    if text != @text or align != @align
      self.contents.clear
      back_color = Color.new(0, 0, 0, 80)
      self.contents.fill_rect(0, y = 12, contents.width, WLH - y, back_color)
      self.contents.font.color = normal_color
      self.contents.draw_text(20, 0, self.width - 72, WLH, text, align)
      @text = text
      @align = align
    end
  end
end

#==============================================================================
# �� Window_ActorCommand
#==============================================================================

#==============================================================================
# �� Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # �� �I�u�W�F�N�g������ ��
  #--------------------------------------------------------------------------
  def initialize
    super(128, 288, 416, 128)
    @column_max = 4
    refresh
    self.active = false
    self.opacity = 0
  end
  #--------------------------------------------------------------------------
  # �� �X�e�[�g���X�V �����n�`��
  #--------------------------------------------------------------------------
  def draw_neomemo7_back
    @neomemo7_clear = false
    for index in 0...@item_max
      x = index * 96
      self.contents.clear_rect(x + 72, WLH * 3, 24, 24)
      next unless Zii.battle_face?
      actor = $game_party.members[index]
      next if actor.hp <= 0
      bitmap = Cache.face(actor.face_name)
      rect = Rect.new(0, 0, 22, 22)
      rect.x = actor.face_index % 4 * 96 + 72
      rect.y = actor.face_index / 4 * 96 + 72
      self.contents.blt(x + 72, WLH * 3, bitmap, rect, 192)
    end
  end
  #--------------------------------------------------------------------------
  # �� �������`�� ��
  #--------------------------------------------------------------------------
  def draw_item(index)
    x = index * 96
    rect = Rect.new(x, 0, 96, 96)
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    actor = $game_party.members[index]
    draw_actor_face(actor, x + 2, 2, 92, 192) if actor.hp > 0 and Zii.battle_face?
    draw_actor_state(actor, x + 0, WLH * 0)
    if Zii.line_name?
      self.contents.font.color = hp_color(actor)
      size = Zii::LINE_SIZE
      self.contents.font.size = size
      self.contents.draw_text(x, WLH * 1+ 20 - size, 80, WLH, actor.name)
      self.contents.font.size = 20
    end
    draw_actor_hp(actor, x, WLH * 2, 80)
    draw_actor_mp(actor, x, WLH * 3, 60)
  end
  #--------------------------------------------------------------------------
  # �� �J�[������X�V
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0                   # �J�[������u�� 0 ����������
      self.cursor_rect.empty        # �J�[���������������
    else                            # �J�[������u�� 0 ����������
      rect = Rect.new(index * 96, 0, 96, 96)
      self.cursor_rect = rect       # �J�[��������`���X�V
    end
  end
end
#==============================================================================
# �� Scene_Battle
#------------------------------------------------------------------------------
# �@�o�g���������������s���N���X�����B
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # �� ��������r���[�|�[�g������
  #--------------------------------------------------------------------------
  alias :neomemo13_create_info_viewport :create_info_viewport
  def create_info_viewport
    neomemo13_create_info_viewport
    @info_viewport.rect.set(0, 0, 544, 416)
    @status_window.x = 128
    @actor_command_window.x = 351
    @actor_command_window.y = 288
  end
  #--------------------------------------------------------------------------
  # �� ��������r���[�|�[�g���X�V
  #--------------------------------------------------------------------------
  alias :neomemo13_update_info_viewport :update_info_viewport
  def update_info_viewport
    ox = @info_viewport.ox
    neomemo13_update_info_viewport
    @info_viewport.ox = ox
  end
  #--------------------------------------------------------------------------
  # �� �p�[�e�B�R�}���h�I�����J�n
  #--------------------------------------------------------------------------
  alias :neomemo13_start_party_command_selection :start_party_command_selection
  def start_party_command_selection
    if $game_temp.in_battle
      @party_command_window.visible = true
      @actor_command_window.visible = false
    end
    neomemo13_start_party_command_selection
  end
 
  #--------------------------------------------------------------------------
  # �� �A�N�^�[�R�}���h�I�����J�n
  #--------------------------------------------------------------------------
  alias :neomemo13_start_actor_command_selection :start_actor_command_selection
  def start_actor_command_selection
    neomemo13_start_actor_command_selection
    @party_command_window.visible = false
    @actor_command_window.visible = true
  end
 
 
  #--------------------------------------------------------------------------
  # �� �����G�L�����I�����I��
  #--------------------------------------------------------------------------
  alias :neomemo13_end_target_enemy_selection :end_target_enemy_selection
  def end_target_enemy_selection
    x = @info_viewport.rect.x
    ox = @info_viewport.ox
    @info_viewport.rect.width += @target_enemy_window.width
    neomemo13_end_target_enemy_selection
    @info_viewport.rect.x = x
    @info_viewport.ox = ox
  end
 
  #--------------------------------------------------------------------------
  # �� �����A�N�^�[�I�����I��
  #--------------------------------------------------------------------------
  alias :neomemo13_end_target_actor_selection :end_target_actor_selection
  def end_target_actor_selection
    x = @info_viewport.rect.x
    ox = @info_viewport.ox
    @info_viewport.rect.width += @target_actor_window.width
    neomemo13_end_target_actor_selection

    @info_viewport.rect.x = x
    @info_viewport.ox = ox
  end
 
  #--------------------------------------------------------------------------
  # �� �A�C�e���I�����J�n
  #--------------------------------------------------------------------------
  alias :neomemo13_start_item_selection :start_item_selection
  def start_item_selection
    neomemo13_start_item_selection
    @item_window.dispose if @item_window != nil
    @help_window.dispose if @help_window != nil
    @help_window = Window_LineHelp.new
    @item_window = Window_Item.new(8, 64, 528, 216)
    @item_window.help_window = @help_window
  end
end

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ 오버 드라이브 - KGC_OverDrive ◆ VX ◆
#_/    ◇ Last update : 2008/08/24 ◇
#_/----------------------------------------------------------------------------
#_/  전용의 게이지를 소비해 사용하는 스킬을 작성합니다.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

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

module KGC
module OverDrive
  # ◆ 드라이브 게이지 최대치
  #  보통은 이대로OK.미조정하고 싶은 경우로 변경.
  GAUGE_MAX = 1000
  # ◆ 드라이브 게이지 증가량
  #  높을 정도 게이지가 모이기 쉽다.
  #  마이너스치를 지정하면 감소.
  #  「피데미지」는, 받은 데미지의 최대 HP 에 대한 비율로 증가량을 산출.
  #  (500 (이)라고, 최대 HP 상당한 데미지로 500 모인다)
  GAIN_RATE = [
     40,  # 공격
    30,  # 피데미지
    0,  # 승리
    0,  # 도주
    0,  # 고독
    100,  # 행동
    160,  # 빈사
     0,  # 방어
  ]  # ← 이 ] (은)는 지우지 않는 것!

  # ◆ 게이지의 초기 갯수
  DEFAULT_GAUGE_NUMBER = 1

  # ◆ 액터의 디폴트 드라이브 타입
  #   0..공격  1..피데미지  2..승리  3..도주  4..고독  5..행동  6..빈사
  #   7..방어
  DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6]
  # ◆ 에너미의 디폴트 드라이브 타입
  DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]

  # ◆ 드라이브 게이지의 개시색 (통상시)
  #  수치  : C[n] (와)과 같은 색.
  #  Color : 지정한 색. ( Color.new(255, 128, 128) 등 )
  GAUGE_NORMAL_START_COLOR = 14
  # ◆ 드라이브 게이지의 종료색 (통상시)
  GAUGE_NORMAL_END_COLOR   = 6
  # ◆ 드라이브 게이지의 개시색 (최대시)
  GAUGE_MAX_START_COLOR    = 10
  # ◆ 드라이브 게이지의 종료색 (최대시)
  GAUGE_MAX_END_COLOR      = 2

  # ◆ 드라이브 게이지의 Y 좌표 보정치
  #  -8 (으)로 하면,HP/MP 게이지와 같은 위치가 됩니다.
  GAUGE_OFFSET_Y = -8
  # ◆ 게이지 축적량의 수치 표기
  #   0 .. 없음  ※게이지가 2 본이상의 경우는 비추천
  #   1 .. 즉치 (축적량 그대로)
  #   2 .. 비율  --> x%
  #   3 .. 비율 (상세 1)  --> x.x%
  #   4 .. 비율 (상세 2)  --> x.xx%
  #   5 .. 축적이 끝난 갯수
  GAUGE_VALUE_STYLE = 2
  # ◆ 게이지 축적량의 font size
  #  너무 크게 하면 이름에 입습니다.
  GAUGE_VALUE_FONT_SIZE = 10

  # ◆ 사망(HP 0) 때에 드라이브 게이지를 0 (으)로 한다
  EMPTY_ON_DEAD = false

  # ◆ 드라이브 게이지를 표시하지 않는 액터
  #  게이지를 숨기는 액터의ID(을)를 배열에 격납.
  HIDE_GAUGE_ACTOR = []
  # ◆ 비전투시는 드라이브 게이지를 숨긴다
  HIDE_GAUGE_NOT_IN_BATTLE = false
  # ◆ 오버 드라이브 스킬미습득이라면 게이지를 숨긴다
  HIDE_GAUGE_NO_OD_SKILLS  = true
  # ◆ 게이지를 숨기고 있는 경우는 게이지를 증가시키지 않는다
  NOT_GAIN_GAUGE_HIDING    = true

  # ◆ 게이지 부족 때는 오버 드라이브 스킬을 숨긴다
  HIDE_SKILL_LACK_OF_GAUGE = false
end
end

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

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

module KGC::OverDrive
  # 드라이브 타입
  module Type
    ATTACK  = 0  # 공격
    DAMAGE  = 1  # 피데미지
    VICTORY = 2  # 승리
    ESCAPE  = 3  # 도주
    ALONE   = 4  # 고독
    ACTION  = 5  # 행동
    FATAL   = 6  # 빈사
    GUARD   = 7  # 방어
  end

  # 축적량 표기
  module ValueStyle
    NONE         = 0  # 없음
    IMMEDIATE    = 1  # 즉치
    RATE         = 2  # 비율
    RATE_DETAIL1 = 3  # 비율 (상세 1)
    RATE_DETAIL2 = 4  # 비율 (상세 2)
    NUMBER       = 5  # 축적이 끝난 갯수
  end

  # 정규 표현
  module Regexp
    # 스킬
    module Skill
      # 오버 드라이브
      OVER_DRIVE = /<(?:OVER_DRIVE|오버 드라이브)s*(d+)?>/i
      # 게이지 증가율
      OD_GAIN_RATE = /<(?:OD_GAIN_RATE|OD게이지 증가율)s*(d+)[%%]?>/i
    end
  end
end

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

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

module KGC
module Commands
  module_function
  #--------------------------------------------------------------------------
  # ○ 액터의 드라이브 게이지의 증감
  #     actor_id : 액터 ID (-1 : 파티 전체)
  #     value    : 증가량 (마이너스도 가능)
  #--------------------------------------------------------------------------
  def gain_actor_od_gauge(actor_id, value)
    if actor_id == -1
      # 생존 멤버 전원의 게이지를 조작
      $game_party.existing_members.each { |actor|
        actor.overdrive += value
      }
    else
      actor = $game_actors[actor_id]
      actor.overdrive += value if actor != nil && actor.exist?
    end
  end
  #--------------------------------------------------------------------------
  # ○ 에너미의 드라이브 게이지의 증감
  #     enemy_index : 에너미 index (-1 : 전체)
  #     value       : 증가량 (마이너스도 가능)
  #--------------------------------------------------------------------------
  def gain_enemy_od_gauge(enemy_index, value)
    if enemy_index == -1
      # 생존 에너미 전원의 게이지를 조작
      $game_troop.existing_members.each { |enemy|
        enemy.overdrive += value
      }
    else
      enemy = $game_troop.members[enemy_index]
      enemy.overdrive += value if enemy != nil && enemy.exist?
    end
  end
  #--------------------------------------------------------------------------
  # ○ 액터의 드라이브 게이지의 취득
  #     actor_id    : 액터 ID
  #     variable_id : 반환값을 격납하는 변수 ID
  #--------------------------------------------------------------------------
  def get_actor_od_gauge(actor_id, variable_id = 0)
    actor = $game_actors[actor_id]
    n = (actor != nil ? actor.overdrive : 0)
    if variable_id > 0
      $game_variables[variable_id] = n
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ○ 에너미의 드라이브 게이지의 취득
  #     enemy_index : 에너미 index
  #     variable_id : 반환값을 격납하는 변수 ID
  #--------------------------------------------------------------------------
  def get_enemy_od_gauge(enemy_index, variable_id = 0)
    enemy = $game_troop.members[enemy_index]
    n = (enemy != nil ? enemy.overdrive : 0)
    if variable_id > 0
      $game_variables[variable_id] = n
    end
    return n
  end
  #--------------------------------------------------------------------------
  # ○ 액터의 드라이브 게이지의 갯수를 설정
  #     actor_id : 액터 ID (-1 : 파티 전체)
  #     number   : 게이지 갯수
  #--------------------------------------------------------------------------
  def set_actor_od_gauge_number(actor_id, number)
    if actor_id == -1
      # 멤버 전원의 갯수를 설정
      $game_party.members.each { |actor|
        actor.drive_gauge_number = number
      }
    else
      actor = $game_actors[actor_id]
      actor.drive_gauge_number = number if actor != nil
    end
  end
  #--------------------------------------------------------------------------
  # ○ 에너미의 드라이브 게이지의 갯수를 설정
  #     enemy_index : 에너미 index (-1 : 전체)
  #     number   : 게이지 갯수
  #--------------------------------------------------------------------------
  def set_enemy_od_gauge_number(enemy_index, number)
    if enemy_index == -1
      # 생존 에너미 전원의 갯수를 설정
      $game_troop.members.each { |enemy|
        enemy.drive_gauge_number = number
      }
    else
      enemy = $game_troop.members[enemy_index]
      enemy.drive_gauge_number = number if enemy != nil
    end
  end
  #--------------------------------------------------------------------------
  # ○ 액터의 드라이브 게이지가 최대나 판정
  #     actor_id : 액터 ID
  #--------------------------------------------------------------------------
  def actor_od_gauge_max?(actor_id)
    actor = $game_actors[actor_id]
    return false if actor == nil
    return actor.overdrive == actor.max_overdrive
  end
  #--------------------------------------------------------------------------
  # ○ 에너미의 드라이브 게이지가 최대나 판정
  #     enemy_index : 에너미 index
  #--------------------------------------------------------------------------
  def enemy_od_gauge_max?(enemy_index)
    enemy = $game_troop.members[enemy_index]
    return false if enemy == nil
    return enemy.overdrive == enemy.max_overdrive
  end
  #--------------------------------------------------------------------------
  # ○ 액터의 드라이브 타입의 변경
  #     actor_id : 액터 ID (-1 : 파티 전체)
  #     types    : 드라이브 타입의 배열 (생략시 : 초기화)
  #--------------------------------------------------------------------------
  def set_actor_drive_type(actor_id, types = nil)
    if actor_id == -1
      # 멤버 전원의 드라이브 타입을 변경
      $game_party.members.each { |actor|
        actor.drive_type = types
      }
    else
      actor = $game_actors[actor_id]
      actor.drive_type = types if actor != nil
    end
  end
  #--------------------------------------------------------------------------
  # ○ 에너미의 드라이브 타입의 변경
  #     enemy_index : 에너미 index (-1 : 전체)
  #     types       : 드라이브 타입의 배열 (생략시 : 초기화)
  #--------------------------------------------------------------------------
  def set_enemy_drive_type(enemy_index, types = nil)
    if enemy_index == -1
      # 에너미 전원의 드라이브 타입을 변경
      $game_troop.members.each { |enemy|
        enemy.drive_type = types
      }
    else
      enemy = $game_troop.members[enemy_index]
      enemy.drive_type = types if enemy != nil
    end
  end
end
end

class Game_Interpreter
  include KGC::Commands
end

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

#==============================================================================
# ■ RPG::Skill
#==============================================================================

class RPG::Skill < RPG::UsableItem
  #--------------------------------------------------------------------------
  # ○ 오버 드라이브의 캐쉬 생성
  #--------------------------------------------------------------------------
  def create_overdrive_cache
    @__is_overdrive = false
    @__od_cost      = KGC::OverDrive::GAUGE_MAX
    @__od_gain_rate = 100

    self.note.each_line { |line|
      case line
      when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
        # 오버 드라이브
        @__is_overdrive = true
        @__od_cost = $1.to_i if $1 != nil
      when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
        # 게이지 증가율
        @__od_gain_rate = $1.to_i
      end
    }

    # 드라이브 스킬이 아니면, 게이지 소비량 0
    unless @__is_overdrive
      @__od_cost = 0
    end
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 스킬일까
  #--------------------------------------------------------------------------
  def overdrive?
    create_overdrive_cache if @__is_overdrive == nil
    return @__is_overdrive
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 소비량
  #--------------------------------------------------------------------------
  def od_cost
    create_overdrive_cache if @__od_cost == nil
    return @__od_cost
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 증가율
  #--------------------------------------------------------------------------
  def od_gain_rate
    create_overdrive_cache if @__od_gain_rate == nil
    return @__od_gain_rate
  end
end

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

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

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 공개 인스턴스 변수
  #--------------------------------------------------------------------------
  attr_writer   :drive_type               # 드라이브 타입
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지량 취득
  #--------------------------------------------------------------------------
  def overdrive
    @overdrive = 0 if @overdrive == nil
    return @overdrive
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 조작
  #--------------------------------------------------------------------------
  def overdrive=(value)
    @overdrive = [[value, max_overdrive].min, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 최대량 취득
  #--------------------------------------------------------------------------
  def max_overdrive
    return KGC::OverDrive::GAUGE_MAX * drive_gauge_number
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 갯수 취득
  #--------------------------------------------------------------------------
  def drive_gauge_number
    if @drive_gauge_number == nil
      @drive_gauge_number = KGC::OverDrive::DEFAULT_GAUGE_NUMBER
    end
    return @drive_gauge_number
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 갯수의 조작
  #--------------------------------------------------------------------------
  def drive_gauge_number=(value)
    @drive_gauge_number = [value, 1].max
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 타입의 취득
  #--------------------------------------------------------------------------
  def drive_type
    return []
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 스킬 습득이 끝난 판정
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ 게이지 표시 판정
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    return false
  end
  #--------------------------------------------------------------------------
  # ○ 게이지 증가 가부 판정
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ 공격시 증가 판정
  #--------------------------------------------------------------------------
  def drive_attack?
    return drive_type.include?(KGC::OverDrive::Type::ATTACK)
  end
  #--------------------------------------------------------------------------
  # ○ 피데미지시 증가 판정
  #--------------------------------------------------------------------------
  def drive_damage?
    return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
  end
  #--------------------------------------------------------------------------
  # ○ 승리시 증가 판정
  #--------------------------------------------------------------------------
  def drive_victory?
    return drive_type.include?(KGC::OverDrive::Type::VICTORY)
  end
  #--------------------------------------------------------------------------
  # ○ 도주시 증가 판정
  #--------------------------------------------------------------------------
  def drive_escape?
    return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
  end
  #--------------------------------------------------------------------------
  # ○ 고독시 증가 판정
  #--------------------------------------------------------------------------
  def drive_alone?
    return drive_type.include?(KGC::OverDrive::Type::ALONE)
  end
  #--------------------------------------------------------------------------
  # ○ 행동시 증가 판정
  #--------------------------------------------------------------------------
  def drive_action?
    return drive_type.include?(KGC::OverDrive::Type::ACTION)
  end
  #--------------------------------------------------------------------------
  # ○ 빈사시 증가 판정
  #--------------------------------------------------------------------------
  def drive_fatal?
    return drive_type.include?(KGC::OverDrive::Type::FATAL)
  end
  #--------------------------------------------------------------------------
  # ○ 방어시 증가 판정
  #--------------------------------------------------------------------------
  def drive_guard?
    return drive_type.include?(KGC::OverDrive::Type::GUARD)
  end
  #--------------------------------------------------------------------------
  # ● 스테이트의 부가
  #     state_id : 스테이트 ID
  #--------------------------------------------------------------------------
  alias add_state_KGC_OverDrive add_state
  def add_state(state_id)
    add_state_KGC_OverDrive(state_id)

    reset_overdrive_on_dead if dead?
  end
  #--------------------------------------------------------------------------
  # ○ 스킬의 소비 드라이브 게이지 계산
  #     skill : 스킬
  #--------------------------------------------------------------------------
  def calc_od_cost(skill)
    return 0 unless skill.is_a?(RPG::Skill)

    return skill.od_cost
  end
  #--------------------------------------------------------------------------
  # ● 스킬의 사용 가능 판정
  #     skill : 스킬
  #--------------------------------------------------------------------------
  alias skill_can_use_KGC_OverDrive? skill_can_use?
  def skill_can_use?(skill)
    return false unless skill_can_use_KGC_OverDrive?(skill)

    return false if calc_od_cost(skill) > overdrive
    return true
  end
  #--------------------------------------------------------------------------
  # ● 데미지의 반영
  #     user : 스킬이나 아이템의 사용자
  #    호출전에 @hp_damage,@mp_damage,@absorbed 하지만 설정되어 있는 것.
  #--------------------------------------------------------------------------
  alias execute_damage_KGC_OverDrive execute_damage
  def execute_damage(user)
    execute_damage_KGC_OverDrive(user)

    increase_overdrive(user)
  end
  #--------------------------------------------------------------------------
  # ○ 사망시 드라이브 게이지 초기화 처리
  #--------------------------------------------------------------------------
  def reset_overdrive_on_dead
    return unless KGC::OverDrive::EMPTY_ON_DEAD

    self.overdrive = 0
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지 증가 처리
  #     attacker : 공격자
  #--------------------------------------------------------------------------
  def increase_overdrive(attacker = nil)
    return unless attacker.is_a?(Game_Battler)  # 공격자가 버틀러가 아니다
    return if self.class == attacker.class      # 공격측과 방어측이 같다
    return if hp_damage == 0 && mp_damage == 0  # 데미지 없음

    if can_gain_overdrive?
      increase_attacker_overdrive(attacker)
      increase_defender_overdrive(attacker)
    end
    reset_overdrive_on_dead if dead?
  end
  #--------------------------------------------------------------------------
  # ○ 공격측의 드라이브 게이지 증가 처리
  #     attacker : 공격자
  #--------------------------------------------------------------------------
  def increase_attacker_overdrive(attacker)
    return unless attacker.drive_attack?  # 드라이브 타입 「공격」없음

    od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
    if attacker.action.kind == 1
      rate = attacker.action.skill.od_gain_rate  # 스킬의 배율을 적용
      od_gain = od_gain * rate / 100
      if rate > 0
        od_gain = [od_gain, 1].max
      elsif rate < 0
        od_gain = [od_gain, -1].min
      end
    end
    attacker.overdrive += od_gain
  end
  #--------------------------------------------------------------------------
  # ○ 방어측의 드라이브 게이지 증가 처리
  #     attacker : 공격자
  #--------------------------------------------------------------------------
  def increase_defender_overdrive(attacker)
    return unless self.drive_damage?  # 드라이브 타입 「데미지」없음

    rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
    od_gain = 0
    od_gain += hp_damage * rate / maxhp if hp_damage > 0
    od_gain += mp_damage * rate / maxmp if mp_damage > 0 && maxmp > 0
    if rate > 0
      od_gain = [od_gain, 1].max
    elsif rate < 0
      od_gain = [od_gain, -1].min
    end
    self.overdrive += od_gain
  end
  #--------------------------------------------------------------------------
  # ● 스킬의 효과 적용
  #     user  : 스킬의 사용자
  #     skill : 스킬
  #--------------------------------------------------------------------------
  alias skill_effect_KGC_OverDrive skill_effect
  def skill_effect(user, skill)
    skill_effect_KGC_OverDrive(user, skill)

    # 아이템으로 스킬을 발동했을 경우는 게이지 소비 판정을 무시
    if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
      return
    end
  end
end

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

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

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 셋업
  #     actor_id : 액터 ID
  #--------------------------------------------------------------------------
  alias setup_KGC_OverDrive setup
  def setup(actor_id)
    setup_KGC_OverDrive(actor_id)

    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 타입의 취득
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
    end
    return @drive_type
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 스킬 습득이 끝난 판정
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    result = false
    # 일시적으로 전투중 플래그를 해제
    last_in_battle = $game_temp.in_battle
    $game_temp.in_battle = false

    self.skills.each { |skill|
      if skill.overdrive?
        result = true
        break
      end
    }
    $game_temp.in_battle = last_in_battle
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 게이지 증가 가부 판정
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
      # 비표시
      return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    end
    if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
      # 미습득
      return false unless overdrive_skill_learned?
    end

    return true
  end
  #--------------------------------------------------------------------------
  # ○ 게이지 표시 판정
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    # 전투중비표시
    if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
      return false
    end
    # 비표시
    return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    # 게이지 증가 불가
    return false unless can_gain_overdrive?

    return true
  end
end

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

#==============================================================================
# ■ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● 오브젝트 초기화
  #     index    : 적그룹내 인덱스
  #     enemy_id : 적캐릭터 ID
  #--------------------------------------------------------------------------
  alias initialize_KGC_OverDrive initialize
  def initialize(index, enemy_id)
    initialize_KGC_OverDrive(index, enemy_id)

    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 타입의 취득
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
    end
    return @drive_type
  end
end

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

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

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 통상시의 색 1 의 취득
  #--------------------------------------------------------------------------
  def od_gauge_normal_color1
    color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 통상시의 색 2 의 취득
  #--------------------------------------------------------------------------
  def od_gauge_normal_color2
    color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 최대시의 색 1 의 취득
  #--------------------------------------------------------------------------
  def od_gauge_max_color1
    color = KGC::OverDrive::GAUGE_MAX_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 최대시의 색 2 의 취득
  #--------------------------------------------------------------------------
  def od_gauge_max_color2
    color = KGC::OverDrive::GAUGE_MAX_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ● 이름의 묘화
  #     actor : 액터
  #     x     : 묘화처 X 좌표
  #     y     : 묘화처 Y 좌표
  #--------------------------------------------------------------------------
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_state(actor, x, y)
    draw_actor_od_gauge(actor, x, y, 70)

    draw_actor_name_KGC_OverDrive(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 묘화
  #     actor : 액터
  #     x     : 묘화처 X 좌표
  #     y     : 묘화처 Y 좌표
  #     width : 폭
  #--------------------------------------------------------------------------
  def draw_actor_od_gauge(actor, x, y, width = 70)
    return unless actor.od_gauge_visible?

    n = actor.overdrive % KGC::OverDrive::GAUGE_MAX
    n = KGC::OverDrive::GAUGE_MAX if actor.overdrive == actor.max_overdrive
    gw = width * n / KGC::OverDrive::GAUGE_MAX
    gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
    gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
    self.contents.fill_rect(x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y,
      width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(
      x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y, gw, 6, gc1, gc2)

    draw_actor_od_gauge_value(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # ○ 드라이브 게이지의 묘화
  #     actor : 액터
  #     x     : 묘화처 X 좌표
  #     y     : 묘화처 Y 좌표
  #     width : 폭
  #--------------------------------------------------------------------------
  def draw_actor_od_gauge_value(actor, x, y, width = 70)
    text = "필살기"
    value = actor.overdrive * 100.0 / KGC::OverDrive::GAUGE_MAX
    case KGC::OverDrive::GAUGE_VALUE_STYLE
    when KGC::OverDrive::ValueStyle::IMMEDIATE
      text = actor.overdrive.to_s
    when KGC::OverDrive::ValueStyle::RATE
      text = sprintf("%d%%", actor.overdrive * 100 / KGC::OverDrive::GAUGE_MAX)
    when KGC::OverDrive::ValueStyle::RATE_DETAIL1
      text = sprintf("%0.1f%%", value)
    when KGC::OverDrive::ValueStyle::RATE_DETAIL2
      text = sprintf("%0.2f%%", value)
    when KGC::OverDrive::ValueStyle::NUMBER
      text = "#{actor.overdrive / KGC::OverDrive::GAUGE_MAX}"
    else
      return
    end

    last_font_size = self.contents.font.size
    new_font_size = KGC::OverDrive::GAUGE_VALUE_FONT_SIZE
    self.contents.font.size = new_font_size
    self.contents.draw_text(
      x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y - new_font_size / 2,
      width, new_font_size, text, 2)
    self.contents.font.size = last_font_size
  end
end

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

#==============================================================================
# ■ Window_Skill
#==============================================================================

if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # ○ 스킬을 리스트에 포함할지
  #     skill : 스킬
  #--------------------------------------------------------------------------
  unless $@
    alias include_KGC_OverDrive? include? if method_defined?(:include?)
  end
  def include?(skill)
    return false if skill == nil

    if defined?(include_KGC_OverDrive?)
      return false unless include_KGC_OverDrive?(skill)
    end

    if skill.overdrive?
      return (@actor.calc_od_cost(skill) <= @actor.overdrive)
    else
      return true
    end
  end

if method_defined?(:include_KGC_OverDrive?)
  #--------------------------------------------------------------------------
  # ● 리프레쉬
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for skill in @actor.skills
      next unless include?(skill)
      @data.push(skill)
      if skill.id == @actor.last_skill_id
        self.index = @data.size - 1
      end
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
end

end  # <-- class
end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

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

#==============================================================================
# ■ Scene_Skill
#==============================================================================

class Scene_Skill < Scene_Base
  #--------------------------------------------------------------------------
  # ● 스킬의 사용 (아군 대상 이외의 사용 효과를 적용)
  #--------------------------------------------------------------------------
  alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
  def use_skill_nontarget
    consume_od_gauge

    use_skill_nontarget_KGC_OverDrive
  end
  #--------------------------------------------------------------------------
  # ○ 스킬 사용시의 드라이브 게이지 소비
  #--------------------------------------------------------------------------
  def consume_od_gauge
    @actor.overdrive -= @actor.calc_od_cost(@skill)
  end
end

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

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

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 전투 종료
  #     result : 결과 (0:승리 1:도주 2:패배)
  #--------------------------------------------------------------------------
  alias battle_end_KGC_OverDrive battle_end
  def battle_end(result)
    increase_overdrive_on_battle_end(result)

    battle_end_KGC_OverDrive(result)
  end
  #--------------------------------------------------------------------------
  # ○ 전투 종료시의 드라이브 게이지 증가 처리
  #     result : 결과 (0:승리 1:도주 2:패배)
  #--------------------------------------------------------------------------
  def increase_overdrive_on_battle_end(result)
    case result
    when 0  # 승리
      od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
      $game_party.existing_members.each { |actor|
        actor.overdrive += od_gain if actor.drive_victory?
      }
    when 1  # 도주
      od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
      $game_party.existing_members.each { |actor|
        actor.overdrive += od_gain if actor.drive_escape?
      }
    end
  end
  #--------------------------------------------------------------------------
  # ● 전투 행동의 실행
  #--------------------------------------------------------------------------
  alias execute_action_KGC_OverDrive execute_action
  def execute_action
    increase_overdrive_on_action

    execute_action_KGC_OverDrive
  end
  #--------------------------------------------------------------------------
  # ○ 행동시의 드라이브 게이지 증가 처리
  #--------------------------------------------------------------------------
  def increase_overdrive_on_action
    battler = @active_battler
    od_gain = 0
    unit = (battler.actor? ? $game_party : $game_troop)

    # 고독 전투
    if battler.drive_alone? && unit.existing_members.size == 1
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
    end
    # 행동
    if battler.drive_action?
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
    end
    # 빈사
    if battler.drive_fatal? && battler.hp < battler.maxhp / 4
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
    end
    # 방어
    if battler.drive_guard? && battler.action.kind == 0 &&
        battler.action.basic == 1
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD]
    end
    battler.overdrive += od_gain
  end
  #--------------------------------------------------------------------------
  # ● 전투 행동의 실행 : 스킬
  #--------------------------------------------------------------------------
  alias execute_action_skill_KGC_OverDrive execute_action_skill
  def execute_action_skill
    execute_action_skill_KGC_OverDrive

    consume_od_gauge
  end
  #--------------------------------------------------------------------------
  # ○ 스킬 사용시의 드라이브 게이지 소비
  #--------------------------------------------------------------------------
  def consume_od_gauge
    skill = @active_battler.action.skill
    @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
  end
end

#############################XP풍묘화 다른거