Este script adiciona melhores efeitos gradiente nas barra medidoras (HP, MP, etc.) do RPG Maker VX.
no Editor de Scripts do RPG Maker VX.
- 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).
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