Neo Gauge - Woratana

[Raizen]

Neo Gauge

Autor: Woratana

Versão: 2.0 - Data: 25/12/2008

Sobre:
Este script adiciona melhores efeitos gradiente nas barra medidoras (HP, MP, etc.) do RPG Maker VX.

Instalação:
Cole este script acima do Principal e abaixo dos Scripts Adicionais no Editor de Scripts do RPG Maker VX.

Funções:
- Suporta barras gradiente no sentido horizontal e vertical.
- Desenha 3 cores gradiente e o usuário pode definir o ponto para desenhar a segunda cor.
- Fácil configuração do estilo da barra.
- 2 novos métodos para ajudar a editar os bitmaps (para scripters).

Script:

Spoiler

#==============================================================================
# Neo Gauge [VX]
#------------------------------------------------------------------------------
# Aumenta as possibilidades de configurações para as barras com efeito 
# gradiente.
#------------------------------------------------------------------------------
# Autor: Woratana (woratana@hotmail.com)
# Lançado em: 25/12/2008
# Versão: 2.0
# Tradução PT: Kyo Panda (http://www.mundorpgmaker.com.br/)
#==============================================================================

#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# - Suporta barras gradiente no sentido horizontal e vertical.
# - Desenha 3 cores gradiente e o usuário pode definir o ponto para desenhar
# a segunda cor.
# - Fácil configuração do estilo da barra.
# - Possue suporte para os scripts KGC Overdrive, DerVVulfman Limit Break e 
# Mog Basic Menu.
# - 2 novos métodos para ajudar a editar os bitmaps (para scripters).
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação:
# #--------------------------------------------------------------------------
#
# Cole este script no "Editor de Scripts" do "RPG Maker VX" acima do guia
# "Principal" e abaixo do guia "Scripts Adicionais".
#
# Configure este script no guia "Configuração" à partir da linha 54 se 
# julgar necessário.
#
#==============================================================================

#==============================================================================
# Window_Base
#------------------------------------------------------------------------------
# Esta é a classe superior à todas as classes de janelas do jogo.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # Configuração
  #--------------------------------------------------------------------------
  
  # Defina aqui se deseja usar o efeito brilhante.
  # Defina true para sim e false para não.
  GAUGE_GLOW_EFFECT = true
  
  # Defina aqui a cor do efeito brilhante.
  # Defina como Color.new(R, G, B, Opacidade).
  GAUGE_GLOW_COLOR = Color.new(  0,   0,   0, 255)
  
  # Defina aqui se deseja usar o contorno nas barras.
  # Defina true para sim e false para não.
  GAUGE_OUTSIDE_BORDER = true
  
  # Defina aqui as cores do contorno das barras.
  # Defina como Color.new(R, G, B, Opacidade).
  GAUGE_OUTSIDE_BORDER_COLOR  = Color.new(255, 255, 255, 255) # 1ª cor
  GAUGE_OUTSIDE_BORDER_COLOR2 = Color.new(255, 255, 255, 255) # 2ª cor
  
  # Defina aqui se deseja limpar os cantos das bordas.
  # Defina true para sim e false para não.
  GAUGE_CLEAR_CORNER_OUTSIDE_BORDER = true
  
  # Defina aqui se deseja usar o contorno interior nas barras.
  # Defina true para sim e false para não.
  GAUGE_INSIDE_BORDER = false
  
  # Defina aqui as cores do contorno interior das barras.
  # Defina como Color.new(R, G, B, Opacidade).
  GAUGE_INSIDE_BORDER_COLOR  = Color.new(255, 255, 255, 255) # 1ª cor
  GAUGE_INSIDE_BORDER_COLOR2 = Color.new(  0,   0,   0, 255) # 2ª cor 

  # Defina aqui a altura da barra de HP (mínimo 6).
  # Sugiro que defina no minimo 8 se estiver usando o contorno interior
  # nas barras.
  HPMP_GAUGE_HEIGHT = 8
  
  # Defina aqui as distâncias adicionais para a barra de HP.
  HPMP_GAUGE_X_PLUS = 0                                # Distância horizontal
  HPMP_GAUGE_Y_PLUS = ((-1) * (HPMP_GAUGE_HEIGHT - 6)) # Distância vertical
  
  # Defina aqui as cores para a barra de fundo.
  # Defina como Color.new(R, G, B, Opacidade).
  BACK_GCOLOR_1 = Color.new(  0,   0,   0, 255) # 1ª cor
  BACK_GCOLOR_2 = Color.new(100, 100, 100, 255) # 2ª cor
  BACK_GCOLOR_3 = Color.new(200, 200, 200, 255) # 3ª cor
  
  # Defina aqui se deseja usar barras Neo Gauge para as barras de HP e MP.
  # Defina true para sim e false para não.
  USE_HP_GAUGE = true # Barra de HP
  USE_MP_GAUGE = true # Barra de MP
  
  # Defina aqui as cores para a barra de HP.
  # Defina como Color.new(R, G, B, Opacidade).
  HP_GCOLOR_1 = Color.new(139,   0,   0, 255) # 1ª cor
  HP_GCOLOR_2 = Color.new(255,   0,   0, 255) # 2ª cor
  HP_GCOLOR_3 = Color.new(255, 255,   0, 255) # 3ª cor

  # Defina aqui as cores para a barra de MP.
  # Defina como Color.new(R, G, B, Opacidade).
  MP_GCOLOR_1 = Color.new(  0,   0, 128, 255) # 1ª cor
  MP_GCOLOR_2 = Color.new(  0, 191, 255, 255) # 2ª cor
  MP_GCOLOR_3 = Color.new(152, 251, 152, 255) # 3ª cor
  
  # Defina aqui o modo de medida utilizado para as barras de Ataque, Defesa,
  # Inteligência e Agilidade.
  # 0 usa o status no nível 99 para medida.
  # 1 ou mais utiliza o número determinado para a medida.
  ADSA_GAUGE_MAX_MODE = 0
  
  # Defina aqui se deseja utilizar as barras de Ataque, Defesa, Inteligência
  # e Agilidade.
  # Defina true para sim e false para não.
  USE_ADSA_GAUGE = false
  
  # Defina aqui as cores para a barra de Ataque.
  # Defina como Color.new(R, G, B, Opacidade).
  ATK_GCOLOR_1 = Color.new(  0,   0, 128, 255) # 1ª cor
  ATK_GCOLOR_2 = Color.new(  0, 191, 255, 255) # 2ª cor
  ATK_GCOLOR_3 = Color.new(152, 251, 152, 255) # 3ª cor
  
  # Defina aqui as cores para a barra de Defesa.
  # Defina como Color.new(R, G, B, Opacidade).
  DEF_GCOLOR_1 = Color.new(  0,   0, 128, 255) # 1ª cor
  DEF_GCOLOR_2 = Color.new(  0, 191, 255, 255) # 2ª cor
  DEF_GCOLOR_3 = Color.new(152, 251, 152, 255) # 3ª cor
  
  # Defina aqui as cores para a barra de Inteligência.
  # Defina como Color.new(R, G, B, Opacidade).
  SPI_GCOLOR_1 = Color.new(  0,   0, 128, 255) # 1ª cor
  SPI_GCOLOR_2 = Color.new(  0, 191, 255, 255) # 2ª cor
  SPI_GCOLOR_3 = Color.new(152, 251, 152, 255) # 3ª cor

  # Defina aqui as cores para a barra de Agilidade.
  # Defina como Color.new(R, G, B, Opacidade).
  AGI_GCOLOR_1 = Color.new(  0,   0, 128, 255) # 1ª cor
  AGI_GCOLOR_2 = Color.new(  0, 191, 255, 255) # 2ª cor
  AGI_GCOLOR_3 = Color.new(152, 251, 152, 255) # 3ª cor
  
  # Defina aqui se deseja usar barras Neo Gauge para as barras dos scripts
  # KGC Overdrive, DerVVulfman Limit Break e Mog Basic Menu.
  # Defina true para sim e false para não.
  USE_KGC_OVERDRIVE  = true # KGC Overdrive
  USE_DVV_LIMITBREAK = true # DerVVulfman Limit Break
  USE_MOG_BASIC_MENU = true # Mog Basic Menu
  
  # Defina aqui as cores para a barra do KGC Overdrive no estado normal.
  # Defina como Color.new(R, G, B, Opacidade).
  KGC_GCOLOR_1 = Color.new(238, 238,   0, 255) # 1ª cor
  KGC_GCOLOR_2 = Color.new(218, 165,  32, 255) # 2ª cor
  KGC_GCOLOR_3 = Color.new(238, 238,   0, 255) # 3ª cor
  
  # Defina aqui as cores para a barra do KGC Overdrive no estado máximo.
  # Defina como Color.new(R, G, B, Opacidade).
  KGC_MAX_GCOLOR_1 = Color.new(255, 127,   0, 255) # 1ª cor
  KGC_MAX_GCOLOR_2 = Color.new(255, 255,  36, 255) # 2ª cor
  KGC_MAX_GCOLOR_3 = Color.new(255, 127,   0, 255) # 3ª cor

  # Defina aqui as cores para a barra do DerVVulfman Limit Break no estado
  # normal.
  # Defina como Color.new(R, G, B, Opacidade).
  DLB_GCOLOR_1 = Color.new(238, 238,   0, 255) # 1ª cor
  DLB_GCOLOR_2 = Color.new(218, 165,  32, 255) # 2ª cor
  DLB_GCOLOR_3 = Color.new(238, 238,   0, 255) # 3ª cor
  
  # Defina aqui as cores para a barra do DerVVulfman Limit Break no estado
  # máximo.
  # Defina como Color.new(R, G, B, Opacidade).
  DLB_MAX_GCOLOR_1 = Color.new(255, 127,   0, 255) # 1ª cor
  DLB_MAX_GCOLOR_2 = Color.new(255, 255,  36, 255) # 2ª cor
  DLB_MAX_GCOLOR_3 = Color.new(255, 127,   0, 255) # 3ª cor
  
  # Defina aqui as cores para a barra de experiência do Mog Basic Menu.
  MOG_EXP_GCOLOR_1 = Color.new(  0, 100,   0, 255) # 1ª cor
  MOG_EXP_GCOLOR_2 = Color.new(  0, 255,   0, 255) # 2ª cor
  MOG_EXP_GCOLOR_3 = Color.new(173, 255,  47, 255) # 3ª cor
  
  #--------------------------------------------------------------------------
  # Fim da configuração
  #--------------------------------------------------------------------------

  #--------------------------------------------------------------------------
  # Definição das cores do medidor de fundo
  #--------------------------------------------------------------------------
  def neo_gauge_back_color
    return BACK_GCOLOR_1, BACK_GCOLOR_2, BACK_GCOLOR_3
  end
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para a barra de HP
  #--------------------------------------------------------------------------
  if USE_HP_GAUGE
  #--------------------------------------------------------------------------
  # Exibição do medidor de HP
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     width : largura
  #--------------------------------------------------------------------------
  def draw_actor_hp_gauge(actor, x, y, width = 120)
    gwidth = width * actor.hp / actor.maxhp
    cg = neo_gauge_back_color
    c1, c2, c3 = cg[0], cg[1], cg[2]
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, c1, c2, c3)
    (1..3).each {|i| eval("c#{i} = HP_GCOLOR_#{i}") }
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gwidth, HPMP_GAUGE_HEIGHT, c1, c2, c3, false, false, width, 30)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para a barra de MP
  #--------------------------------------------------------------------------
  if USE_MP_GAUGE
  #--------------------------------------------------------------------------
  # Exibição do medidor de MP
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     width : largura
  #--------------------------------------------------------------------------  
  def draw_actor_mp_gauge(actor, x, y, width = 120)
    gwidth = width * actor.mp / [actor.maxmp, 1].max
    cg = neo_gauge_back_color
    c1, c2, c3 = cg[0], cg[1], cg[2]
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, c1, c2, c3)
    (1..3).each {|i| eval("c#{i} = MP_GCOLOR_#{i}") }
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gwidth, HPMP_GAUGE_HEIGHT, c1, c2, c3, false, false, width, 40)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para os parâmetros
  #--------------------------------------------------------------------------
  if USE_ADSA_GAUGE
  #--------------------------------------------------------------------------
  # Exibição dos parâmetros
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     type  : tipo do valor (0～3)
  #--------------------------------------------------------------------------
  def draw_actor_parameter(actor, x, y, type)
    case type
    when 0
      parameter_name = Vocab::atk
      parameter_value = actor.atk
      parameter_value_max = actor.maxatk
      (1..3).each {|i| eval("@c#{i} = ATK_GCOLOR_#{i}") }
    when 1
      parameter_name = Vocab::def
      parameter_value = actor.def
      parameter_value_max = actor.maxdef
      (1..3).each {|i| eval("@c#{i} = DEF_GCOLOR_#{i}") }
    when 2
      parameter_name = Vocab::spi
      parameter_value = actor.spi
      parameter_value_max = actor.maxspi
      (1..3).each {|i| eval("@c#{i} = SPI_GCOLOR_#{i}") }
    when 3
      parameter_name = Vocab::agi
      parameter_value = actor.agi
      parameter_value_max = actor.maxagi
      (1..3).each {|i| eval("@c#{i} = AGI_GCOLOR_#{i}") }
    end
    # Exibe as barras dos parâmetros
    parameter_value_max = ADSA_GAUGE_MAX_MODE if ADSA_GAUGE_MAX_MODE > 0
    width = 156
    gwidth = width * parameter_value / [parameter_value_max, 1].max
    cg = neo_gauge_back_color
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, cg[0], cg[1], cg[2])
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gwidth, HPMP_GAUGE_HEIGHT, @c1, @c2, @c3, false, false, width, 40)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 120, WLH, parameter_name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para as barras do KGC Overdrive 
  #--------------------------------------------------------------------------
  if USE_KGC_OVERDRIVE
  #--------------------------------------------------------------------------
  # Exibição do medidor de overdrive
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     width : largura
  #--------------------------------------------------------------------------  
  def draw_actor_od_gauge(actor, x, y, width = 120)
    return unless actor.od_gauge_visible?
    gw = width * actor.overdrive / actor.max_overdrive
    cg = neo_gauge_back_color
    c1, c2, c3 = cg[0], cg[1], cg[2]
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, c1, c2, c3)
    if gw == width # Máximo
      (1..3).each {|i| eval("@c#{i} = KGC_MAX_GCOLOR_#{i}") }
    else # Normal
      (1..3).each {|i| eval("@c#{i} = KGC_GCOLOR_#{i}") }
    end
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gw, HPMP_GAUGE_HEIGHT, @c1, @c2, @c3, false, false, width, 50)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para as barras do DerVVulfman Limit 
  # Break
  #--------------------------------------------------------------------------
  if USE_DVV_LIMITBREAK
  #--------------------------------------------------------------------------
  # Exibição do medidor de quebra de limite
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     width : largura
  #--------------------------------------------------------------------------  
  def draw_actor_lb(actor, x, y, width = 120)
    return unless actor.lb_gauge_visible?
    gw = width * actor.limitbreak / LB_MAX
    cg = neo_gauge_back_color
    c1, c2, c3 = cg[0], cg[1], cg[2]
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, c1, c2, c3)
    if gw == width # Máximo
      (1..3).each {|i| eval("@c#{i} = DLB_MAX_GCOLOR_#{i}") }
    else # Normal
      (1..3).each {|i| eval("@c#{i} = DLB_GCOLOR_#{i}") }
    end
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gw, HPMP_GAUGE_HEIGHT, @c1, @c2, @c3, false, false, width, 50)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Definição do uso da barra Neo Gauge para a barra de experiência do Mog 
  # Basic Menu
  #--------------------------------------------------------------------------
  if USE_MOG_BASIC_MENU
  #--------------------------------------------------------------------------
  # Exibição do medidor de experiência
  #     actor : herói
  #     x     : exibe na coordenada X
  #     y     : exibe na coordenada Y
  #     width : largura
  #-------------------------------------------------------------------------- 
  def draw_actor_exp_meter(actor, x, y, width = 100)  
    if actor.next_exp != 0
      exp = actor.now_exp
    else
      exp = 1
    end
    gw = width * exp / [actor.next_exp, 1].max
    cg = neo_gauge_back_color
    c1, c2, c3 = cg[0], cg[1], cg[2]
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    width, HPMP_GAUGE_HEIGHT, c1, c2, c3)
    (1..3).each {|i| eval("c#{i} = MOG_EXP_GCOLOR_#{i}") }
    draw_neo_gauge(x + HPMP_GAUGE_X_PLUS, y + WLH - 8 + HPMP_GAUGE_Y_PLUS, 
    gw, HPMP_GAUGE_HEIGHT, c1, c2, c3, false, false, width, 50)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, "Exp")    
    self.contents.font.color = normal_color
    xr = x + width
    self.contents.draw_text(xr - 60, y, 60, WLH,  actor.next_rest_exp_s, 2)
  end
  end # Fim da definição
  #--------------------------------------------------------------------------
  # Exibição da barra Neo Gauge
  #     x           : exibe na coordenada X
  #     y           : exibe na coordenada Y
  #     width       : largura da barra
  #     height      : altura da barra
  #     color1      : primeira cor (lado esquerdo)
  #     color2      : segunda cor (centro)
  #     color3      : terceira cor (lado direito)
  #     vertical    : sentido do gradiente (true: vertical e 
  #                   false: horizontal)
  #     outline     : definição do contorno (true: exibe e false: não exibe)
  #     max_width   : largura máxima do gradiente à ser exibido (a largura 
  #                   máxima se tornará a altura máxima se no sentido 
  #                   vertical.
  #     color2_spot : o ponto de exibição da 2ª cor (1: Esquerda, 50: Centro
  #                   e 100: Direita)
  #-------------------------------------------------------------------------
  def draw_neo_gauge(x, y, width, height, color1, color2, color3, 
    vertical = false, outline = true, max_width = nil, color2_spot = 50)
    if max_width == nil
      max_width = vertical ? height : width
    end
    glow = GAUGE_GLOW_EFFECT # Define o efeito brilhante
    dx = x; dy = y # Armazena as coordenas X e Y
    x = y = 0 # Muda x e y para bitmap temporário
    bitmap = Bitmap.new(max_width, height) # Cria um bitmap para exibir a barra
    if glow # Se brilhante
      if outline # Se exibindo contorno
        # Cria o retângulo do efeito brilhante
        if vertical; rect = Rect.new(x, y, width, max_width)
        else; rect = Rect.new(x, y, max_width, height)
        end
        bitmap.fill_rect(rect, GAUGE_GLOW_COLOR) # Exibe efeito brilhante
        # Limpa os cantos
        bitmap.neo_clear_corner(rect.x, rect.y, rect.width, rect.height) 
      else # Se não brilhante
        height -= 2; width -= 2; x += 1; y += 1
        if GAUGE_INSIDE_BORDER
          height -= 2; width -= 2; x += 1; y += 1
        end; end; end # Fim da exibição do efeito brlhnate
    # Define a posição e o tamanho para o gradiente
    if vertical # Se exibindo a barra gradiente no sentido vertical
      if glow; gx = gx2 = x + 1; gy = y + 1 # Se brilhante
      else; gx = gx2 = x; gy = y # Se não brilhante
      end
      gy2 = gy - 1 + ((color2_spot*max_width)/100)
      gw = gw2 = width - 2; gh = ((color2_spot*max_width)/100)
      gh2 = max_width - gh - 2
      # Exibe a barra gradiente no sentido vertical
      bitmap.gradient_fill_rect(gx, gy, gw, gh, color1, color2, true)
      bitmap.gradient_fill_rect(gx2, gy2, gw2, gh2, color2, color3, true)
      gh = (gh + gh2) # Muda a altura da barra para desenhar o contorno
    else # Exibe a barra no sentido horizontal
      if glow; gx = x; gy = gy2 = y # Se brilhante
        gx = x + 1; gy = gy2 = y + 1; 
      else; gx = x; gy = gy2 = y # Se não brilhante
      end
      gx2 = gx - 1 + ((color2_spot*max_width)/100)
      gw = ((color2_spot*max_width)/100); gh = gh2 = (height - 2)
      gw2 = max_width - gw - 2
      # Exibe a barra gradiente no sentido horizontal
      bitmap.gradient_fill_rect(gx, gy, gw, gh, color1, color2)
      bitmap.gradient_fill_rect(gx2, gy2, gw2, gh2, color2, color3)
      gw = (gw + gw2) # Muda a largura da barra para desenhar o contorno
    end
    if outline # Se definido usar contorno
      if GAUGE_OUTSIDE_BORDER # Exibe o contorno
        bitmap.draw_neo_border(gx, gy, gw, gh, GAUGE_OUTSIDE_BORDER_COLOR, 
        GAUGE_OUTSIDE_BORDER_COLOR2)
        bitmap.neo_clear_corner(gx, gy, gw, gh) if GAUGE_CLEAR_CORNER_OUTSIDE_BORDER
      end
      if GAUGE_INSIDE_BORDER # Exibe o contorno interior
        gx += 1; gy += 1; gw -= 2; gh -= 2
        bitmap.draw_neo_border(gx, gy, gw, gh, GAUGE_INSIDE_BORDER_COLOR,
        GAUGE_INSIDE_BORDER_COLOR2)
      end
    end
    # Corta a largura da barra da largura máxima para largura
    rect = Rect.new(0, 0, width, bitmap.height)
    self.contents.blt(dx, dy, bitmap, rect)
    bitmap.dispose # Exclui o bitmap
  end
end

#==============================================================================
# Bitmap
#------------------------------------------------------------------------------
# Classe que comanda toda e qualquer imagem exibida no jogo.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novos métodos: draw_neo_border e neo_clear_corner.
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # Desenha um contorno gradiente entorno de algum objeto
  #     x      : exibe na coordenada X
  #     y      : exibe na coordenada Y
  #     width  : largura
  #     height : altura
  #     color  : primeira cor (lado esquerdo)
  #     color2 : segunda cor (lado direito)
  #     size   : tamanho do contorno (por padrão é 1)
  #--------------------------------------------------------------------------
  def draw_neo_border(x, y, width, height, color, color2 = color, size = 1)
    gradient_fill_rect(x, y, width, size, color, color2) # Acima
    fill_rect(x, y, size, height, color) # Esquerda
    fill_rect(x + width - size, y, size, height, color2) # Direita
    gradient_fill_rect(x, y + height - size, width, size, color, color2) # Abaixo
  end
  #--------------------------------------------------------------------------
  # Limpa os quatro cantos de uma área específica
  #     x      : limpa na coordenada X
  #     y      : limpa na coordenada Y
  #     width  : largura
  #     height : altura
  #     size   : tamanho que será limpado os cantos
  #--------------------------------------------------------------------------
  def neo_clear_corner(x, y, width, height, size = 1)
    clear_rect(x, y, size, size)
    clear_rect(x + width - size, y, size, size)
    clear_rect(x, y + height - size, size, size)
    clear_rect(x + width - size, y + height - size, size, size)
  end
end

#==============================================================================
# Game_Battler
#------------------------------------------------------------------------------
# Esta classe controla as unidades da batalha (personagens e inimigos). Esta
# classe é uma superclasse de Game_Actor e Game_Enemy. 
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novos métodos: maxatk, maxdef, maxspi e maxagi.
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # Configuração do ataque máximo
  #--------------------------------------------------------------------------
  def maxatk
    n = atk
    n = n - actor.parameters[2, @level] + actor.parameters[2, 99] if self.is_a?(Game_Actor)
    return n
  end
  #--------------------------------------------------------------------------
  # Configuração da defesa máxima
  #--------------------------------------------------------------------------
  def maxdef
    n = atk
    n = n - actor.parameters[3, @level] + actor.parameters[3, 99] if self.is_a?(Game_Actor)
    return n
  end
  #--------------------------------------------------------------------------
  # Configuração da inteligência máxima
  #--------------------------------------------------------------------------
  def maxspi
    n = atk
    n = n - actor.parameters[4, @level] + actor.parameters[4, 99] if self.is_a?(Game_Actor)
    return n
  end
  #--------------------------------------------------------------------------
  # Configuração da agilidade máxima
  #--------------------------------------------------------------------------
  def maxagi
    n = atk
    n = n - actor.parameters[5, @level] + actor.parameters[5, 99] if self.is_a?(Game_Actor)
    return n
  end
end

[close]

Screenshots:

Spoiler

[close]

Créditos:
- Woratana, criador do script.