CogWheel Style Menu Bars

[syvkal]

Syvkal's Menu Bars
Version: 4.1

Introduction

Inspired by CogWheel, Made completely by me ^.^

Features

• Plug 'N' Play Cogwheel Style Menu Bars
  • HP and MP Bars
    
  • Exp Bars
    
  • Parameter Bars
    
  • DVVs Limit Break Bar
    
  
  
• Use colours from the System Windowskin
  • This is currently only for Parameter bars
    
  
  
• Make your own custom 'CogWheel Style' bars easily
  
• Slanted Bars
  
• Vertical Bars - Both Slanted and Normal
  
• Ring and Cricle Bars
  
• Curved Edges Bars
  
  Update List

  Updated to version 1.5

  • I have addded the choice to use colours from the System Windowskin (Inspired by Kylock)
    • This is currently only for Parameter bars, but will be updated for the main bars aswell if I like the colours
      
    
    
  • Easier way to customise max parameter values added
    

  Updated to version 1.9

  • Add a way to make your own custom 'CogWheel Style' bars easily
    

  Updated to version 2.0

  • I cleaned up the script
    
  • I added coding for DVVs Limit Break Bars
    

  Updated to version 2.5

  • I cleaned up the script more
    
  • Added Slanted Bar Fill
    

  Updated to version Beta 3.0

  • Added slanted bars
    
  • Errors and Bugs still present so in Beta...
    

  Updated to version 3.0

  • Proper Slanted Bars finished
    
  • Vertical Bars - Both Slanted and Normal
    
  • Removed slanted bar gradient (no one would use it xD )
    

  Updated to version 4.0

  • Ring/Circle Bars added
    
  • Exp Bar added
    
  • Made changing the main bar colours easier
    

  Updated to version 4.1

  • Removed Double and Triple Range checks
    
  • Made Slanted Bars HUD compatible (even ones which refresh every frame)
    
  • Greatly Improved Ring Bars speed
    
  • Curved Edges Bars added
    
  • Added coding to make it easier for me xD
    
  • Reduced code size
    
  Screenshots
  
  
  Screenshots

  
  
  
  
  
  
  
  
  Couldn't be bothered with Vertical Bar Screen shots xD
  
  
  
  Script
  
  
  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
  
  Instructions
  
  Put it under the Materials Section
  Further instructions can be found in the script header.
  
  Compatibility
  
  Should work with most things, but I'm not 100% sure
  
  Credits and Thanks
  
  Thanks to Wortana for making a fix for 'gradient_fill_rect' (included in the script)