#==============================================================================
# [VX] <+ [Neo Gauge] ENGINE -> by Woratana
#------------------------------------------------------------------------------
# ◦ by Woratana [[email protected]]
# ◦ Released on: 25/12/2008 (D-M-Y)
# ◦ Version: 2
#---------------------------------------------------------------------------
# ◦ Exclusive Script @ RPG RPG Revolution (http://www.rpgrevolution.com/)
#---------------------------------------------------------------------------
#### [FEATURES] ####
# - Support horizontal/vertical gradient bar
# - Draw 3 colors gradient / user can choose spot to draw second color
# - Easy to setting gauge style
# - Support KGC Overdrive, DerVVulfman Limit Break, and Mog Basic Menu
# - 2 New methods to help edit bitmap (for scripters)
#------------------------------------------------------------------------------
#==============================================================================
class Window_Base < Window
#==========================================================================
# NEO GAUGE SETTING #
# Color: Color.new(Red, Green, Blue) # Each number you can put integer 0-255
# * You can use this site to get RGB color:
# http://web.njit.edu/~kevin/rgb.txt.html
#==========================================================================
GAUGE_GLOW_EFFECT = true # Use glow effect?
GAUGE_GLOW_COLOR = Color.new(150,150,150) # Glow color
GAUGE_OUTSIDE_BORDER = false # Use outside border?
GAUGE_OUTSIDE_BORDER_COLOR = Color.new(255,255,255)#Color.new(0, 0, 0)
GAUGE_OUTSIDE_BORDER_COLOR2 = Color.new(255,255,255)#Color.new(0, 0, 0)
GAUGE_CLEAR_CORNER_OUTSIDE_BORDER = true
GAUGE_INSIDE_BORDER = false # Use inside border?
GAUGE_INSIDE_BORDER_COLOR = Color.new(255, 255, 255)
GAUGE_INSIDE_BORDER_COLOR2 = Color.new(0, 0, 0)
#==========================================================================
#=============================================================
# NEO HP/MP/STATS GAUGE SETTING #
#=============================================================
HPMP_GAUGE_HEIGHT = 7 # gauge height (minumum: 6)
# Recommend to use HPMP_GAUGE_HEIGHT at least 8,
# if you're using GAUGE_INSIDE_BORDER in Neo-Gauge
HPMP_GAUGE_X_PLUS = 0 # Move gauge horizontally (+,-)
HPMP_GAUGE_Y_PLUS = ((-1)*(HPMP_GAUGE_HEIGHT - 12)) # (+,-)
# Change '((-1)*(HPMP_GAUGE_HEIGHT - 6))' to number to move gauge vertically
# BACK GAUGE COLORS
BACK_GCOLOR_1 = Color.new(0,0,0) # Black [Color1]
BACK_GCOLOR_2 = Color.new(0,0,0) # Dark Gray [Color2]
BACK_GCOLOR_3 = Color.new(0,0,0) # Light Gray [Color3]
USE_HP_GAUGE = true # Use HP Gauge? (true/false)
USE_MP_GAUGE = true # Use MP Gauge?
# HP GAUGE COLORS
HP_GCOLOR_1 = Color.new(139,0,0) # Dark Red
HP_GCOLOR_2 = Color.new(255,0,0) # Pure Red
HP_GCOLOR_3 = Color.new(255,255,0) # Pure Yellow
# MP GAUGE COLORS
MP_GCOLOR_1 = Color.new(0,0,128) # Dark Blue
MP_GCOLOR_2 = Color.new(0,191,255) # Blue
MP_GCOLOR_3 = Color.new(152,251,152) # Light Green
#---------------------------------------------------------
ADSA_GAUGE_MAX_MODE = 0
# Mode for Attack/Defense/Spirit/Agility Gauge Max:
# 0: use stats at level 99 for gauge's max
# 1 or more: use that number for gauge's max
USE_ADSA_GAUGE = true # Use Attack/Defense/Spirit/Agility Gauge?
# ATTACK GAUGE COLORS
ATK_GCOLOR_1 = Color.new(255,51,51)
ATK_GCOLOR_2 = Color.new(255,102,0)
ATK_GCOLOR_3 = Color.new(204,102,51)
# DEFENSE GAUGE COLORS
DEF_GCOLOR_1 = Color.new(51,102,255)
DEF_GCOLOR_2 = Color.new(102,102,204)
DEF_GCOLOR_3 = Color.new(51,153,204)
# SPIRIT GAUGE COLORS
SPI_GCOLOR_1 = Color.new(102,51,187)
SPI_GCOLOR_2 = Color.new(170,51,204)
SPI_GCOLOR_3 = Color.new(221,102,204)
# AGILITY GAUGE COLORS
AGI_GCOLOR_1 = Color.new(51,153,51)
AGI_GCOLOR_2 = Color.new(102,204,0)
AGI_GCOLOR_3 = Color.new(153,204,153)
#----------------------------------------------
USE_KGC_OVERDRIVE = false # Use KGC Overdrive Gauge?
USE_DVV_LIMITBREAK = false # Use DerVVulfman Limit Break Gauge?
USE_MOG_BASIC_MENU = false # Use Mog Basic Menu (EXP) Gauge?
# KGC_OVERDRIVE NORMAL GAUGE COLORS
KGC_GCOLOR_1 = Color.new(238, 238, 0)
KGC_GCOLOR_2= Color.new(218, 165, 32)
KGC_GCOLOR_3 = Color.new(238, 238, 0)
# KGC_OVERDRIVE MAX GAUGE COLORS
KGC_MAX_GCOLOR_1 = Color.new(255, 127, 0)
KGC_MAX_GCOLOR_2 = Color.new(255, 255, 36)
KGC_MAX_GCOLOR_3 = Color.new(255, 127, 0)
# DerVVulfman Limit Break NORMAL GAUGE COLORS
DLB_GCOLOR_1 = Color.new(238, 238, 0)
DLB_GCOLOR_2 = Color.new(218, 165, 32)
DLB_GCOLOR_3 = Color.new(238, 238, 0)
# DerVVulfman Limit Break MAX GAUGE COLORS
DLB_MAX_GCOLOR_1 = Color.new(255, 127, 0)
DLB_MAX_GCOLOR_2 = Color.new(255, 255, 36)
DLB_MAX_GCOLOR_3 = Color.new(255, 127, 0)
# Mog Basic Menu EXP GAUGE COLORS
MOG_EXP_GCOLOR_1 = Color.new(0,100,0)
MOG_EXP_GCOLOR_2 = Color.new(0, 255, 0)
MOG_EXP_GCOLOR_3 = Color.new(173,255,47)
#===================================================================
#-------------------------------------------------------------------
# [END] NEO GAUGE FINAL SETUP
#===================================================================
#------------------------------------------------------------
# * Neo Gauge Back Color: Return back colors
#------------------------------------------------------------
def neo_gauge_back_color
return BACK_GCOLOR_1, BACK_GCOLOR_2, BACK_GCOLOR_3
end
#--------------------------------------------------------------------------
# [Rewrite] * Draw HP gauge
#--------------------------------------------------------------------------
if USE_HP_GAUGE
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
#--------------------------------------------------------------------------
# [Rewrite] * Draw MP Gauge
#--------------------------------------------------------------------------
if USE_MP_GAUGE
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
#--------------------------------------------------------------------------
# [Rewrite] * Draw Parameters
#--------------------------------------------------------------------------
if USE_ADSA_GAUGE
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
# Draw parameter gauge
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
#--------------------------------------------------------------------------
# [Rewrite] * KGC_OVERDRIVE Gauge
#--------------------------------------------------------------------------
if USE_KGC_OVERDRIVE
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 # Max?
(1..3).each {|i| eval("@c#{i} = KGC_MAX_GCOLOR_#{i}") }
else # Not Max~
(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
#--------------------------------------------------------------------------
# [Rewrite] * DerVVulfman Limit Break Gauge
#--------------------------------------------------------------------------
if USE_DVV_LIMITBREAK
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 # Max?
(1..3).each {|i| eval("@c#{i} = DLB_MAX_GCOLOR_#{i}") }
else # Not Max~
(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
#--------------------------------------------------------------------------
# [Rewrite] * Mog Basic Menu Plus EXP Gauge
#--------------------------------------------------------------------------
if USE_MOG_BASIC_MENU
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
#--------------------------------------------------------------------------
# * Draw Neo Gauge: Draw Gauge with 3 Colors & Outline
# x : draw spot x-coordinate
# y : draw spot y-coordinate
# width : gauge width
# height : gauge height
# color1 : first color (left side)
# color2 : second color (center)
# color3 : last color (right side)
# vertical : vertical gauge? (true: vertical | false: horizontal)
# outline : draw glow & outline? (true: draw | false: draw only gradient)
# max_width : max_width that gradient will draw before cut to width
# (max_width will becomes max_height in vertical gauge)
# color2_spot = spot to draw color 2 [1:Left <- (default)50:Center -> 100:Right]
#-------------------------------------------------------------------------
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 # Set glow effect
dx = x; dy = y # Store draw spot X/Y
x = y = 0 # Change x, y for temp. bitmap
bitmap = Bitmap.new(max_width, height) # Create temp. bitmap to draw gauge
if glow # If GLOW
if outline # If drawing outline
# Create Glow rect
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) # Draw Glow
bitmap.neo_clear_corner(rect.x, rect.y, rect.width, rect.height) # Clear Corner
else # Not drawing outline
height -= 2; width -= 2; x += 1; y += 1
if GAUGE_INSIDE_BORDER
height -= 2; width -= 2; x += 1; y += 1
end; end; end # End Draw Glow0
# Set Position/Size for Gradient
if vertical # If drawing vertical bar
if glow; gx = gx2 = x + 1; gy = y + 1 # If GLOW
else; gx = gx2 = x; gy = y # If NOT GLOW
end
gy2 = gy - 1 + ((color2_spot*max_width)/100)
gw = gw2 = width - 2; gh = ((color2_spot*max_width)/100)
gh2 = max_width - gh - 2
# Draw Vertical Gradient Bar
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) # Change gauge height for draw border
else # Drawing horizontal bar
if glow; gx = x; gy = gy2 = y # If GLOW
gx = x + 1; gy = gy2 = y + 1;
else; gx = x; gy = gy2 = y # If NOT GLOW
end
gx2 = gx - 1 + ((color2_spot*max_width)/100)
gw = ((color2_spot*max_width)/100); gh = gh2 = (height - 2)
gw2 = max_width - gw - 2
# Draw Horizontal Gradient Bar
bitmap.gradient_fill_rect(gx, gy, gw, gh, color1, color2)
bitmap.gradient_fill_rect(gx2, gy2, gw2, gh2, color2, color3)
gw = (gw + gw2) # Change gauge width for draw border
end
if outline # If user want outline, draw borders
if GAUGE_OUTSIDE_BORDER # Draw outside border
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 # Draw inside border
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
# Cut gauge's width from 'max_width' to 'width'
rect = Rect.new(0, 0, width, bitmap.height)
self.contents.blt(dx, dy, bitmap, rect)
bitmap.dispose # Delete bitmap
end
end
#==============================================================================
# [Bitmap: 2 New Methods] by Woratana
# => Draw Neo Border: Draw border around specific area
# => Neo Clear Corner: Clear 4 corners of specific area
#------------------------------------------------------------------------------
class Bitmap
#--------------------------------------------------------------------------
# * Draw Neo Border: Draw gradient border around specific area
# x : area x-coordinate
# y : area y-coordinate
# width : area width
# height : area height
# color : border color (left side)
# color2 : border color (right side)
# size : border size (default is 1)
#--------------------------------------------------------------------------
def draw_neo_border(x, y, width, height, color, color2 = color, size = 1)
gradient_fill_rect(x, y, width, size, color, color2) # Top
fill_rect(x, y, size, height, color) # Left
fill_rect(x + width - size, y, size, height, color2) # Right
gradient_fill_rect(x, y + height - size, width, size, color, color2) # Down
end
#--------------------------------------------------------------------------
# * Neo Clear Corner: Clear 4 corners of specific area
# x : area x-coordinate
# y : area y-coordinate
# width : area width
# height : area height
# size : area (size * size) that will be clear from corners
#--------------------------------------------------------------------------
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_Batter: 4 New Methods] by Woratana
# Add method to find maximum stats
#------------------------------------------------------------------------------
class Game_Battler
def maxatk
n = atk
n = n - actor.parameters[2, @level] + actor.parameters[2, 99] if self.is_a?(Game_Actor)
return n
end
def maxdef
n = atk
n = n - actor.parameters[3, @level] + actor.parameters[3, 99] if self.is_a?(Game_Actor)
return n
end
def maxspi
n = atk
n = n - actor.parameters[4, @level] + actor.parameters[4, 99] if self.is_a?(Game_Actor)
return n
end
def maxagi
n = atk
n = n - actor.parameters[5, @level] + actor.parameters[5, 99] if self.is_a?(Game_Actor)
return n
end
end
. 
