[VX Script] CogWheel Style Menu Bars

Script
Code:
#==============================================================================

# ** Syvkal's Menu Bars

#------------------------------------------------------------------------------

# by Syvkal

# Version 4.1

# 05-20-08

#==============================================================================

#

#  - INTRODUCTION -

#

#  This system implements a series of Plug 'N' Play Menu Bars

#  The Bars were inspired CogWheel, but all coding was done by me

#   ( Except Wortana's 'gradient_fill_rect' Bug Fix )

#

#------------------------------------------------------------------------------

#

#  - USAGE -

#

#  This system will work as soon as you put it in the Script Editor

#  You can edit the script from the Configuration System

#  However, it has also been made so you can easily make your own bars

#

#       ---------------------------------------------------

#

#  To draw a bar use:

#     draw_custom_gauge

#

#  Followed by:

#     (value, max, x, y, color1, color2, width, height, slanted, up)

#

#     value    : bar calculation value

#     max      : bar max value

#     x        : draw spot x-coordinate

#     y        : draw spot y-coordinate

#     color1   : bar gradient color 1          EITHER Color.new(r,g,b,a)

#     color2   : bar gradient color 2          OR Numeric Text color

#     width    : Width

#     height   : Height

#     slanted  : draw slanted bar

#     vertical : draw bar vertically

#

#       ---------------------------------------------------

#

#  To draw a ring use:

#     draw_custom_ring

#

#  Followed by:

#     (value, max, x, y, color1, color2, radius, height, amount, start, reverse)

#     value   : bar calculation value

#     max     : bar max value

#     x       : draw spot x-coordinate

#     y       : draw spot y-coordinate

#     color1  : bar gradient color 1

#     color2  : bar gradient color 2

#     radius  : distance from center point

#     height  : Height

#     amount  : size of ring   - default 360Â°

#     start   : start position - max 360Â°

#     reverse : draw ring in reverse

#  

#------------------------------------------------------------------------------

#

#  - SCRIPTERS USAGE -

#

#  I have added a few extra features to allow scripters to easily use the bars

#  Seeing as the bars can be drawn Normal, Vertical or in a Ring I've added a 

#  feature to allow you to turn off the bars when drawing an actors HP, MP etc.

#  When drawing an actors HP etc. simply add 'true' on the end. Like this:

#       draw_actor_hp(actor, x, y, width, true)

#

#  I've also separated the different bars so they're easier to draw

#

#   draw_actor_hp_gauge(actor, x, y, width)         Will draw a normal bar

#   draw_actor_hp_gauge(actor, x, y, width, true)   Will draw a vertical bar

#   draw_actor_hp_ring(actor, x, y, radius, height, amount, start)

#                                                   Will draw a ring

#

#------------------------------------------------------------------------------

#

#  - SCRIPT CALLS -

#

#  There are no script calls necessary to enable this script

#  However, you can change any of the constants in game if you wish

#  This can be done by the Script Call Funtion in an event

#

#  For example:

#      COG::HPMPSLANT = true

#

#  Will make the HP and MP bars Slant

#  And setting it to false will turn them back to normal

#

#==============================================================================

module BAR

   #===================================================#

   #  **  C O N F I G U R A T I O N   S Y S T E M  **  #

   #===================================================#

  # Parameter Max Value

    P_MAX = 500

 # The system uses a 'rate' feature. It is set when drawing a bar

 # The 'rate' is how much the bar is filled as a decimal (max : 1)

 # This is used to enable color change as the bar decreased in amount

    $rate = 0    # Don't touch this

 # The system uses a series of CONSTANTS that can be edited here

 # They control the basic gauge colors and the manner the gauge is filled:

  # Gauge Border Colors

    COLOR1 = Color.new(0, 0, 0, 192)         # Outer Border

    COLOR2 = Color.new(255, 255, 192, 192)   # Inner Border

  # Gauge Empty filler

    COLOR3 = Color.new(0, 0, 0, 12)          # Half of Inner Shading

    COLOR4 = Color.new(64, 0, 0, 92)         # Half of Inner Shading

  # Gauge Settings

    EMPTY  = false   # EMPTY  gauge (false - Side : true - Vertical)

    FILLER = false   # FILLER gauge (false - Side : true - Vertical)

  # Border Settings    -    Applies only to standard bars

    CORNER = false                            # Remove corners?

 # The Parameter colors can be text colors taken from the windowskin or

 # colors like above. You don't need set your own 'rate' functions

 # it does it for you 

  # Parameter Gauge Color1

    ATKCOLOR1 = 2

    DEFCOLOR1 = 17

    SPICOLOR1 = 30

    AGICOLOR1 = 12

  # Parameter Gauge Color2

    ATKCOLOR2 = 20

    DEFCOLOR2 = 21

    SPICOLOR2 = 31

    AGICOLOR2 = 4

 # The system has been made to use a series of SWITCHES that can be edited here

 # They control whether certain Bars are Normal or Slanted:

    HPMPSLANT  = false    # Slanted HP and MP Bars?

    EXPSLANT   = false    # Slanted Exp Bars?

    PARSLANT   = false    # Slanted Parameter Bars?

    DVVLBSLANT = true     # Slanted Limit Break Bars?

   #===================================================#

   #  ** C O M P L E X   C O N F I G U R A T I O N **  #

   #===================================================#

 # The system allows you to edit the main gauge colous from here

 # Functions had to be used instead of Constants so the $rate feature still works

 # Edit only if you know what you're doing:

  def self::hpcolor1 # HP Guage Color1

    return Color.new(80 - 24 * $rate, 80 * $rate, 14 * $rate, 192)

  end

  def self::hpcolor2 # HP Guage Color2

    return Color.new(240 - 72 * $rate, 240 * $rate, 62 * $rate, 192)

  end

  def self::mpcolor1 # MP Guage Color1

    return Color.new(14 * $rate, 80 - 24 * $rate, 80 * $rate, 192)

  end

  def self::mpcolor2 # MP Guage Color2

    return Color.new(62 * $rate, 240 - 72 * $rate, 240 * $rate, 192)

  end

  def self::expcolor1 # EXP Guage Color1

    Color.new(80 * $rate, 80 - 80 * $rate ** 2, 80 - 80 * $rate, 192)

  end

  def self::expcolor2 # EXP Guage Color2

    Color.new(240 * $rate, 240 - 240 * $rate ** 2, 240 - 240 * $rate, 192)

  end  

   #===================================================#

   #  **     E N D   C O N F I G U R A T I O N     **  #

   #===================================================#

end

#==============================================================================

# ** Game_Actor

#------------------------------------------------------------------------------

#  Added EXP and Next Level EXP for numeric for calculations

#==============================================================================

class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------

  # * Get EXP - numeric for calculations

  #--------------------------------------------------------------------------  

  def now_exp

    return @exp - @exp_list[@level]

  end

  #--------------------------------------------------------------------------

  # * Get Next Level EXP - numeric for calculations

  #-------------------------------------------------------------------------- 

  def next_exp

    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0

  end

end

#==============================================================================

# ** Window_Base

#------------------------------------------------------------------------------

#  Added the 'Draw' functions for each gauge

#==============================================================================

class Window_Base < Window

  #--------------------------------------------------------------------------

  # * Includes The BAR Module

  #--------------------------------------------------------------------------  

  include BAR

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------  

  alias draw_actor_parameter_original draw_actor_parameter

  #--------------------------------------------------------------------------

  # * Draw HP gauge

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_actor_hp_gauge(actor, x, y, width = 120, vertical = false)

    $rate = actor.hp.to_f / actor.maxhp

    gw = width * actor.hp / actor.maxhp

    w = vertical ? 6 : width; h = vertical ? width : 6

    HPMPSLANT ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, BAR::hpcolor1, BAR::hpcolor2, vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, BAR::hpcolor1, BAR::hpcolor2, vertical)

  end

  #--------------------------------------------------------------------------

  # * Draw MP gauge

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_actor_mp_gauge(actor, x, y, width = 120, vertical = false)

    $rate = actor.mp.to_f / [actor.maxmp, 1].max

    gw = width * actor.mp / [actor.maxmp, 1].max

    w = vertical ? 6 : width; h = vertical ? width : 6

    HPMPSLANT ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, BAR::mpcolor1, BAR::mpcolor2, vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, BAR::mpcolor1, BAR::mpcolor2, vertical)

  end

  #--------------------------------------------------------------------------

  # * Draw Exp gauge

  #     actor    : actor

  #     x        : draw spot x-coordinate

  #     y        : draw spot y-coordinate

  #     width    : Width

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_actor_exp_gauge(actor, x, y, width = 170, vertical = false)

    $rate = actor.now_exp.to_f / [actor.next_exp, 1].max

    gw = width * actor.now_exp / [actor.next_exp, 1].max

    w = vertical ? 6 : width; h = vertical ? width : 6

    EXPSLANT ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, BAR::expcolor1, BAR::expcolor2, vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, BAR::expcolor1, BAR::expcolor2, vertical)

  end

  #--------------------------------------------------------------------------

  # * Draw Parameters

  #     hide_bar : draw Parameters without gauge

  #--------------------------------------------------------------------------

  def draw_actor_parameter(actor, x, y, type, hide_bar = false)

    hide_bar ? nil : draw_actor_parameter_gauge(actor, x, y, type)

    draw_actor_parameter_original(actor, x, y, type)

  end

  #--------------------------------------------------------------------------

  # * Draw Parameters gauge

  #     actor    : actor

  #     x        : draw spot x-coordinate

  #     y        : draw spot y-coordinate

  #     type     : Type of parameters (0-3)

  #     width    : Width

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_actor_parameter_gauge(actor, x, y, type, width = 160, vertical = false)

    case type

    when 0

      e1 = actor.atk

      gc1 = ATKCOLOR1.is_a?(Integer) ? text_color(ATKCOLOR1) : ATKCOLOR1

      gc2 = ATKCOLOR2.is_a?(Integer) ? text_color(ATKCOLOR2) : ATKCOLOR2

    when 1

      e1 = actor.def

      gc1 = DEFCOLOR1.is_a?(Integer) ? text_color(DEFCOLOR1) : DEFCOLOR1

      gc2 = DEFCOLOR2.is_a?(Integer) ? text_color(DEFCOLOR2) : DEFCOLOR2

    when 2

      e1 = actor.spi

      gc1 = SPICOLOR1.is_a?(Integer) ? text_color(SPICOLOR1) : SPICOLOR1

      gc2 = SPICOLOR2.is_a?(Integer) ? text_color(SPICOLOR2) : SPICOLOR2

    when 3

      e1 = actor.agi

      gc1 = AGICOLOR1.is_a?(Integer) ? text_color(AGICOLOR1) : AGICOLOR1

      gc2 = AGICOLOR2.is_a?(Integer) ? text_color(AGICOLOR2) : AGICOLOR2

    end

    e2 = P_MAX

    rate = [e1.to_f / e2.to_f, 1].min

    gw = width * [e1.to_f / e2.to_f, 1].min

    r = gc2.red * rate

    g = (gc2.green - 72) * rate

    b = gc2.blue  * rate

    a = gc2.alpha

    w = vertical ? 6 : width; h = vertical ? width : 6

    PARSLANT ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical)

  end

  #--------------------------------------------------------------------------

  # * Draw Custom gauge

  #     value    : bar calculation value

  #     max      : bar max value

  #     x        : draw spot x-coordinate

  #     y        : draw spot y-coordinate

  #     color1   : bar gradient color 1

  #     color2   : bar gradient color 2

  #     width    : Width

  #     height   : Height

  #     slanted  : draw slanted bar

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_custom_gauge(value, max, x, y, color1, color2, width=120, height=6, slanted = false, vertical = false)

    rate = [value.to_f / max.to_f, 1].min

    gw = width * [value.to_f / max.to_f, 1].min

    gc1 = color1.is_a?(Integer) ? text_color(color1) : color1

    gc2 = color2.is_a?(Integer) ? text_color(color2) : color2

    r = gc2.red * rate

    g = (gc2.green - 72) * rate

    b = gc2.blue  * rate

    a = gc2.alpha

    w = vertical ? 6 : width; h = vertical ? width : 6

    slanted ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical)

  end

  #--------------------------------------------------------------------------

  # * Draw Limit Break gauge

  #     vertical : draw bar vertically

  #--------------------------------------------------------------------------

  def draw_actor_lb(actor, x, y, width = 120, vertical = false)

    return unless actor.lb_gauge_visible?

    st1 = lb_gauge_normal_start_color; st2 = lb_gauge_max_start_color

    ed1 = lb_gauge_normal_end_color; ed2 = lb_gauge_max_end_color

    rate = actor.limitbreak.to_f / [LB_MAX, 1].max

    gw = width * actor.limitbreak / LB_MAX

    gc1 = (gw == width ? st2 : Color.new(st1.red,st1.green-(10*rate),st1.blue-(10*rate), 192))

    gc2 = (gw == width ? ed2 : Color.new(ed1.red,ed1.green-(10*rate),ed1.blue-(10*rate), 192))

    w = vertical ? 6 : width; h = vertical ? width : 6

    DVVLBSLANT ? self.contents.cogwheel_fill_slant(x, y + WLH - 8, gw, w, h, gc1, gc2, vertical) : 

    self.contents.cogwheel_fill_rect(x, y + WLH - 8, gw, w, h, gc1, gc2, vertical)

  end  

  #--------------------------------------------------------------------------

  # * Draw HP gauge ring

  #     actor   : actor

  #     x       : draw spot x-coordinate

  #     y       : draw spot y-coordinate

  #     radius  : distance from center point

  #     height  : Height

  #     amount  : size of ring   - default 360Â°

  #     start   : start position - max 360Â°

  #     reverse : draw ring in reverse

  #--------------------------------------------------------------------------

  def draw_actor_hp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)

    $rate = actor.hp.to_f / actor.maxhp

    gw = amount * actor.hp / actor.maxhp

    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::hpcolor1, BAR::hpcolor2, amount, start, reverse)

  end

  #--------------------------------------------------------------------------

  # * Draw MP gauge ring

  #     actor   : actor

  #     x       : draw spot x-coordinate

  #     y       : draw spot y-coordinate

  #     radius  : distance from center point

  #     height  : Height

  #     amount  : size of ring   - default 360Â°

  #     start   : start position - max 360Â°

  #     reverse : draw ring in reverse

  #--------------------------------------------------------------------------

  def draw_actor_mp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)

    $rate = actor.mp.to_f / [actor.maxmp, 1].max

    gw = amount * actor.mp / [actor.maxmp, 1].max

    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::mpcolor1, BAR::mpcolor2, amount, start, reverse)

  end

  #--------------------------------------------------------------------------

  # * Draw Exp gauge ring

  #     actor   : actor

  #     x       : draw spot x-coordinate

  #     y       : draw spot y-coordinate

  #     radius  : distance from center point

  #     height  : Height

  #     amount  : size of ring   - default 360Â°

  #     start   : start position - max 360Â°

  #     reverse : draw ring in reverse

  #--------------------------------------------------------------------------

  def draw_actor_exp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)

    $rate = actor.now_exp.to_f / [actor.next_exp, 1].max

    gw = amount * actor.now_exp / [actor.next_exp, 1].max

    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::expcolor1, BAR::expcolor2, amount, start, reverse)

  end

  #--------------------------------------------------------------------------

  # * Draw Custom gauge ring

  #     value   : bar calculation value

  #     max     : bar max value

  #     x       : draw spot x-coordinate

  #     y       : draw spot y-coordinate

  #     color1  : bar gradient color 1

  #     color2  : bar gradient color 2

  #     radius  : distance from center point

  #     height  : Height

  #     amount  : size of ring   - default 360Â°

  #     start   : start position - max 360Â°

  #     reverse : draw ring in reverse

  #--------------------------------------------------------------------------

  def draw_custom_ring(value, max, x, y, color1, color2, radius, height, amount = 360, start = 0, reverse = false)

    rate = [value.to_f / max.to_f, 1].min

    gw = amount * [value.to_f / max.to_f, 1].min

    gc1 = color1.is_a?(Integer) ? text_color(color1) : color1

    gc2 = color2.is_a?(Integer) ? text_color(color2) : color2

    r = gc2.red * rate

    g = (gc2.green - 72) * rate

    b = gc2.blue  * rate

    a = gc2.alpha

    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, gc1, Color.new(r, g, b, a), amount, start, reverse)

  end

  #--------------------------------------------------------------------------

  # * Draw HP

  #     hide_bar : draw Parameters without gauge

  #--------------------------------------------------------------------------

  def draw_actor_hp(actor, x, y, width = 120, hide_bar = false)

    hide_bar ? nil : draw_actor_hp_gauge(actor, x, y, width)

    self.contents.font.color = system_color

    self.contents.draw_text(x, y, 30, WLH, Vocab::hp_a)

    self.contents.font.color = hp_color(actor)

    last_font_size = self.contents.font.size

    xr = x + width

    if width < 120

      self.contents.draw_text(xr - 44, y, 44, WLH, actor.hp, 2)

    else

      self.contents.draw_text(xr - 99, y, 44, WLH, actor.hp, 2)

      self.contents.font.color = normal_color

      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)

      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxhp, 2)

    end

  end

  #--------------------------------------------------------------------------

  # * Draw MP

  #     hide_bar : draw Parameters without gauge

  #--------------------------------------------------------------------------

  def draw_actor_mp(actor, x, y, width = 120, hide_bar = false)

    hide_bar ? nil : draw_actor_mp_gauge(actor, x, y, width)

    self.contents.font.color = system_color

    self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)

    self.contents.font.color = mp_color(actor)

    last_font_size = self.contents.font.size

    xr = x + width

    if width < 120

      self.contents.draw_text(xr - 44, y, 44, WLH, actor.mp, 2)

    else

      self.contents.draw_text(xr - 99, y, 44, WLH, actor.mp, 2)

      self.contents.font.color = normal_color

      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)

      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxmp, 2)

    end

  end

  #--------------------------------------------------------------------------

  # * Draw Exp

  #     actor    : actor

  #     x        : draw spot x-coordinate

  #     y        : draw spot y-coordinate

  #     width    : Width

  #     hide_bar : draw Parameters without gauge

  #--------------------------------------------------------------------------

  def draw_actor_exp(actor, x, y, width = 170, hide_bar = false)

    hide_bar ? nil : draw_actor_exp_gauge(actor, x, y, width)

    self.contents.font.color = system_color

    self.contents.draw_text(x, y, 45, WLH, "Exp")

    self.contents.font.color = normal_color

    xr = x + width

    if width < 170

      self.contents.draw_text(xr - 60, y, 60, WLH,  actor.next_rest_exp_s, 2)   

    else

      self.contents.draw_text(xr - 131, y, 60, WLH, actor.exp_s, 2)

      self.contents.draw_text(xr - 71, y, 11, WLH, "/", 2)

      self.contents.draw_text(xr - 60, y, 60, WLH, actor.next_exp_s, 2)

    end

  end

end

#==============================================================================

# ** Window_SkillStatus

#------------------------------------------------------------------------------

#  Edited so te Bars don't cut off

#==============================================================================

class Window_SkillStatus < Window_Base

  #--------------------------------------------------------------------------

  # * Refresh

  #--------------------------------------------------------------------------

  def refresh

    self.contents.clear

    draw_actor_name(@actor, 4, 0)

    draw_actor_level(@actor, 140, 0)

    draw_actor_hp(@actor, 238, 0)

    draw_actor_mp(@actor, 390, 0)

  end

end

#==============================================================================

# ** Bitmap

#------------------------------------------------------------------------------

#  Added gauge Calculations

#==============================================================================

class Bitmap

  #--------------------------------------------------------------------------

  # * Includes The BAR Module

  #--------------------------------------------------------------------------  

  include BAR

  #--------------------------------------------------------------------------

  # * Wortana's 'gradient_fill_rect' Bug Fix 

  #--------------------------------------------------------------------------

  alias gradient_original gradient_fill_rect unless method_defined?('gradient_original')

  def gradient_fill_rect(*args)

    args.pop if !args.last if args.size == 4 || 7 and !args.last

    gradient_original(*args)

  end

  #--------------------------------------------------------------------------

  # * CogWheel Style Fill of Rect

  #--------------------------------------------------------------------------

  def cogwheel_fill_rect(x, y, gw, width, height, gc1, gc2, up = false)

    rect_border(x-2, y-2, width+4, height+4, COLOR1, CORNER)

    rect_border(x-1, y-1, width+2, height+2, COLOR2, CORNER)

    gradient_fill_rect(x, y, width, height, COLOR3, COLOR4, EMPTY)

    gradient_fill_rect(x, y, up ? width : gw, up ? gw : height, gc1, gc2, FILLER)

  end

  #--------------------------------------------------------------------------

  # * CogWheel Style Fill of Slanted Rect

  #--------------------------------------------------------------------------

  def cogwheel_fill_slant(x, y, gw, width, height, gc1, gc2, up = false)

    bgx = up ? 2 : 4; bdx = up ? 1 : 2

    bgy = up ? 4 : 2; bdy = up ? 2 : 1

    bgw = up ? 4 : 8; bdw = up ? 2 : 4

    bgh = up ? 8 : 4; bdh = up ? 4 : 2

    slant_border(x-bgx, y-bgy, width+bgw, height+bgh, COLOR1, up)

    slant_border(x-bdx, y-bdy, width+bdw, height+bdh, COLOR2, up)

    gradient_fill_slant(x, y, width, height, COLOR3, COLOR4, EMPTY, up)

    gradient_fill_slant(x, y,up ? width : gw,up ? gw : height, gc1, gc2, FILLER, up)

  end

  #--------------------------------------------------------------------------

  # * CogWheel Style Fill of Ring

  #--------------------------------------------------------------------------

  def cogwheel_fill_ring(x, y, gw, radius, height, gc1, gc2, amount = 360, start = 0, reverse = false)

    fill_ring(x-2, y-2, radius, height+4, COLOR1, amount, start, reverse)

    fill_ring(x-1, y-1, radius, height+2, COLOR2, amount, start, reverse)

    if amount >= 220

      gradient_fill_ring(x, y, radius, height, COLOR3, COLOR4, [amount/2, 180].min, start, reverse)

      gradient_fill_ring(x, y, radius, height, COLOR4, COLOR3, [amount/2, 180].min, start+(amount/2), reverse)

    else

      gradient_fill_ring(x, y, radius, height, COLOR3, COLOR4, [amount, 360].min, start, reverse)

    end

    if gw >= 220

      gw1 = amount/2; gw2 = gw / 2

      gradient_fill_ring(x, y, radius, height, gc1, gc2, gw1, start, reverse)

      gradient_fill_ring(x, y, radius, height, gc2, gc1, gw2, start +(amount/2), reverse)

    else

      gradient_fill_ring(x, y, radius, height, gc1, gc2, gw, start, reverse)

    end

  end

  #--------------------------------------------------------------------------

  # * Fill of Border

  #--------------------------------------------------------------------------

  def rect_border(x, y, width, height, gc1, edge = false)

    fill_rect(x + (edge ? 1 : 0), y, width - (edge ? 2 : 0), 2, gc1)

    fill_rect(x + (edge ? 1 : 0), y+(height-2), width - (edge ? 2 : 0), 2, gc1)

    fill_rect(x, y+1, 2, height-2, gc1)

    fill_rect(x +(width-2), y+1, 2, height-2, gc1)

  end

  #--------------------------------------------------------------------------

  # * Gradient Fill of Slanted Rect

  #--------------------------------------------------------------------------

  def gradient_fill_slant(x, y, width, height, gc1, gc2, vertical = false, up = false)

    if up

      for i in 1..width

        if vertical

          gradient_fill_rect(x + width - i, y+i+1, 1, (height-2)-width, gc1, gc2, vertical)

        else

          color = get_gradient_pixel(gc1, gc2, width, i)

          fill_rect(x + width - i, y+i+1, 1, (height-2)-width, color)

        end

      end

    else

      for i in 1..height

        if vertical

          color = get_gradient_pixel(gc1, gc2, height, i)

          fill_rect(x+i+1, y + height - i, (width-2)-height, 1, color)

        else

          gradient_fill_rect(x+i+1, y + height - i, (width-2)-height, 1, gc1, gc2)

        end

      end

    end

  end  

  #--------------------------------------------------------------------------

  # * Fill of Slanted Rect

  #--------------------------------------------------------------------------

  def fill_slant(x, y, width, height, gc1, up = false)

    oh = up ? width : height

    for i in 1..oh

      if up

        fill_rect(x + width -i, y+i, 1, height-width, gc1)

      else

        fill_rect(x+i, y + height -i, width-height, 1, gc1)

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Fill of Slanted Border

  #--------------------------------------------------------------------------

  def slant_border(x, y, width, height, gc1, up = false)

    oh = up ? width : height

    for i in 1..oh-2

      if up

        fill_rect(x + width-1 -i, y+((height-1)-width)+i, 1, 2, gc1)

        fill_rect(x + width-1 -i, y+1+i, 1, 2, gc1)

        fill_rect(x + width-1, y+1, 1, height-width, gc1)

        fill_rect(x, y+width, 1, height-width, gc1)

      else

        fill_rect(x+((width-1)-height)+i, y + height-1 -i, 2, 1, gc1)

        fill_rect(x+1+i, y + height-1 -i, 2, 1, gc1)

        fill_rect(x+1, y + height -1, width-height, 1, gc1)

        fill_rect(x+height, y, width-height, 1, gc1)

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Fill of Ring

  #--------------------------------------------------------------------------

  def fill_ring(ox, oy, radius, height, gc1, amount = 360, start = 0, reverse = false)

    d = 2.0 * Math::PI / 360

    for i in 1..[amount, 360].min

      s = i + start

      if reverse

        x = ox + ( radius * Math.sin( d * s ) ).to_i

        y = oy - ( radius * Math.cos( d * s ) ).to_i

      else

        x = ox - ( radius * Math.cos( d * s ) ).to_i

        y = oy + ( radius * Math.sin( d * s ) ).to_i

      end

      fill_rect(x, y, height, height, gc1)

    end

  end

  #--------------------------------------------------------------------------

  # * Gradient Fill of Ring

  #--------------------------------------------------------------------------

  def gradient_fill_ring(ox, oy, radius, height, gc1, gc2, amount = 360, start = 0, reverse = false)

    d = 2.0 * Math::PI / 360

    for i in 1..amount

      s = i + start

      if reverse

        x = ox + ( radius * Math.sin( d * s ) ).to_i

        y = oy - ( radius * Math.cos( d * s ) ).to_i

      else

        x = ox - ( radius * Math.cos( d * s ) ).to_i

        y = oy + ( radius * Math.sin( d * s ) ).to_i

      end

      color = get_gradient_pixel(gc1, gc2, amount, i)

      fill_rect(x, y, height, height, color)

    end

  end

  #--------------------------------------------------------------------------

  # * Get Pixel Color for Gradient Fill

  #--------------------------------------------------------------------------

  def get_gradient_pixel(gc1, gc2, amount, i)

    red = gc1.red * (amount - i) / amount + gc2.red * i / amount

    green = gc1.green * (amount - i) / amount + gc2.green * i / amount

    blue = gc1.blue * (amount - i) / amount + gc2.blue * i / amount

    alpha = gc1.alpha * (amount - i) / amount + gc2.alpha * i / amount

    return Color.new(red, green, blue, alpha) 

  end

end