#==============================================================================
# [VX] <+ [Neo Gauge] ENGINE -> by Woratana
#------------------------------------------------------------------------------
# ◦ by Woratana [woratana@hotmail.com]
# ◦ 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(0,0,0) # Glow color
 
  GAUGE_OUTSIDE_BORDER = true # 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 = 8 # 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 - 6)) # (+,-)
  # 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(100, 100, 100) # Dark Gray [Color2]
  BACK_GCOLOR_3 = Color.new(200, 200, 200) # 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(0,0,128)
  ATK_GCOLOR_2 = Color.new(0,191,255)
  ATK_GCOLOR_3 = Color.new(152,251,152)
 
  # DEFENSE GAUGE COLORS
  DEF_GCOLOR_1 = Color.new(0,0,128)
  DEF_GCOLOR_2 = Color.new(0,191,255)
  DEF_GCOLOR_3 = Color.new(152,251,152)
 
  # SPIRIT GAUGE COLORS
  SPI_GCOLOR_1 = Color.new(0,0,128)
  SPI_GCOLOR_2 = Color.new(0,191,255)
  SPI_GCOLOR_3 = Color.new(152,251,152)

  # AGILITY GAUGE COLORS
  AGI_GCOLOR_1 = Color.new(0,0,128)
  AGI_GCOLOR_2 = Color.new(0,191,255)
  AGI_GCOLOR_3 = Color.new(152,251,152)
 
  #----------------------------------------------
 
  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

# Neo Burst Gauge.
# Requires Neo Gauge Final by woratana and Burst Gauge by wltr3565.

module WLTR
module BURST_GAUGE_SETUP
 
TEXT_X = 10 #Text's X coordinate. Positive numbers will make the text move to
            #right. Negative numbers will make the text move to left. Counted by
            #pixels.
           
TEXT_Y = 0  #Text's Y coordinate. Positive numbers will make the text move to
            #bottom. Negative numbers will make the text move to top. Counted by
            #pixels.

NEW_WLH = 24 #Just in case that the "Burst" text didn't shown properly. It's
            #because the needed room, line height, doesn't enough to show the
            #entire text. Enter it to your liking, but don't enter it 16 or
            #under, else it won't show anything.
           
end
end

class Window_base < Window

  # Burst Gauge gradient colors (Red, Green, Blue)
  BURST_GCOLOR_1 = Color.new(163, 151, 219)
  BURST_GCOLOR_2 = Color.new(163, 151, 255)
  BURST_GCOLOR_3 = Color.new(236, 0, 140)

  # Maximum Burst Gauge gradient colors (Red, Green, Blue)
  BURST_MAX_GCOLOR_1 = Color.new(236, 0, 140)
  BURST_MAX_GCOLOR_2 = Color.new(199, 203, 255)
  BURST_MAX_GCOLOR_3 = Color.new(236, 0, 140)

  def draw_burst_gauge(x = 0, y = 295, width = 366)
    self.contents.clear
    gw = width * $game_party.Burst_Gauge / $game_party.total_burst
    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} = BURST_MAX_GCOLOR_#{i}") }
    else # Not Max~
      (1..3).each {|i| eval("@c#{i} = BURST_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)
    text = sprintf(WLTR::BURST_GAUGE_SETUP::BURST_NAME)
    self.contents.draw_text(WLTR::BURST_GAUGE_SETUP::TEXT_X,
WLTR::BURST_GAUGE_SETUP::TEXT_Y,200,WLTR::BURST_GAUGE_SETUP::NEW_WLH, text)
  end
end