?
Evangelista 2009.09.04 15:46

얀쿡 파티창

댓글
?
봉시기 2009.09.04 22:43

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

댓글
?
이프 2009.09.06 08:45

오... 이쁜데요?

댓글
카르와푸딩의아틀리에 2009.09.06 13:54

# ★ 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

댓글
카르와푸딩의아틀리에 2009.09.06 13:54

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ 오버 드라이브 - 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

댓글
?
타로카드 2009.09.06 13:57

와...

댓글
카르와푸딩의아틀리에 2009.09.06 14:11

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

#################### Breadlords Improved Battle status #########################
## Can show up to 4 states per actor, shows faces, and if you want it to it ##
## can show the actors character graphics. ##
################################################################################
class Window_BattleStatus < Window_Selectable

def show_character?
return false ## If you want to show the actor character set this to true
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]
i = actor.face_name
j = actor.face_index
a = actor.character_name
b = actor.character_index
draw_face(i, j, rect.x, rect.y)
self.contents.font.color = hp_color(actor)
size = 14
self.contents.font.size = size
self.contents.draw_text(x, WLH * 1 + 20 - size, 80, WLH, actor.name)
self.contents.font.size = 20
draw_actor_hp(actor, 96 * index, WLH + 30, 92)
draw_actor_mp(actor, 96 * index, WLH + 50, 92)
draw_actor_state(actor, rect.x + (92 - (actor.states.size * 24)), 0)
if show_character?
draw_character(a,b, rect.x + 64, WLH*2 + 12)
end
end

def update_cursor
if @index < 0
self.cursor_rect.empty
else
rect = Rect.new(index * 96, 0, 96, 96)
self.cursor_rect = rect
end
end

def update
super
if Input.repeat?(Input::RIGHT)
Sound.play_cursor
cursor_down(Input.trigger?(Input::RIGHT))
end
if Input.repeat?(Input::LEFT)
Sound.play_cursor
cursor_up(Input.trigger?(Input::LEFT))
end
end

end

댓글

Category

List of Articles
분류	제목	글쓴이	날짜	조회 수
공지	아방스 게시물 · 댓글 작성 규칙 (최근 수정일 2015.11.25) 17	완폐남™	2012.07.17	142678
잡담	ID/PW 찾기 및 로그아웃 불가 3	어데이드	2026.04.13	75
막장	뭐지...? 1	무명시절	2026.04.13	19
잡담	2026년 콘텐츠 창의인재동반사업 ""게임 개발 효율화를 위한 AI 활용 개발자 양성 멘토링"" 멘티 모집	13	2026.04.01	44
잡담	오늘 말고 저번에 1	우사준	2026.02.21	147
잡담	🎮✨ [KOREA INDIEGAME SHOWCASE] BIC 2025 온라인 페스티벌 플레이 인증 EVENT✨🎮	gls2024	2025.08.08	362
잡담	게임업계에 대한 현실을 알려주실 수 있을까요? 2	데브조	2025.08.06	392
가입	웹게임 텍스트 RPG 에타츠	게이킹	2025.07.22	279
제작 일지	열심히 제작중인 MMORPG The Caine 입니다!	TheCaine	2025.06.27	291
막장	안하면 안오는 걸까?	무명시절	2025.05.02	304
가입	안녕하세요	政兜	2025.02.27	350
가입	가입인사	망녕	2025.02.19	288
설문	몬스터 소재 추천받습니다.	UMC	2025.02.02	334
가입	가입인사 남겨봅니다	JTB	2025.01.10	328
가입	안녕하세요, 인디게임에 관심있는 일러스트레이터입니다.	리뱡	2024.12.28	370
잡담	[한국콘텐츠진흥원] 게임레벨업쇼케이스 2024 참가 신청 안내	gls2024	2024.11.19	362
잡담	제23회 넷마블게임콘서트 개최안내 (강연자 전용준,진성건)	wavemedia	2024.11.13	291
잡담	[한국콘텐츠진흥원] 게임레벨업쇼케이스 2024가 개최됩니다!	gls2024	2024.11.06	338
잡담	[한국콘텐츠진흥원] GLS in 지스타2024 100% 즐기기!	gls2024	2024.11.05	276
잡담	원래 자랑 잘 안하려고 하는데... 1	무명시절	2024.10.24	431
잡담	생존 신고(말 그대로) 2	Alkaid	2024.10.19	351

쓰기