[RGSS/2/3] Drago - Font Enhance

#==============================================================================
# ** Drago - Font Enhance
# Version : 1.10
# Author : LiTTleDRAgo
#==============================================================================
#
# Explanation :
#
#    This script adds some enhancement to default Font class such as
#    underline, strikethrough or gradient
#
#------------------------------------------------------------------------------
" :Example

    bitmap = Bitmap.new(640,480)

    bitmap.font.underline     = true
    bitmap.font.strikethrough = true

  # (RGSS2 & RGSS3 already have this feature)
    bitmap.font.shadow_color = Color.new(0,0,0,180) # *
    bitmap.font.shadow       = true

  # * In RGSS2 and RGSS3, shadow color is set from text color

  # (RGSS3 already have this feature)
    bitmap.font.out_color     = Color.new(0,0,0,180)
    bitmap.font.outline       = true

    bitmap.font.gradient_color      = Color.blue
    bitmap.font.vertical_gradient   = true
    bitmap.font.horizontal_gradient = true

  # vertical_gradient and horizontal_gradient cannot go together,
  # if you enable any of them, the other will disabled

    bitmap.dispose
"
#==============================================================================



($imported ||= {})[:drg_font_enhance] = 1.10

core_engine = "This script needs Drago - Core Engine ver 1.60 or above"
($imported[:drg_core_engine] || 0) >= 1.60 || raise(core_engine)
#==============================================================================
# ** Font
#------------------------------------------------------------------------------
#
#==============================================================================
class Font
  #--------------------------------------------------------------------------
  # * Self
  #--------------------------------------------------------------------------
  class << self
    #------------------------------------------------------------------------
    # * Class Variables
    #------------------------------------------------------------------------
    attr_accessor     :default_underline,   :default_strikethrough
    attr_accessor     :default_horiz_grad,  :default_vert_grad
    attr_sec_accessor :default_shadow_height,        2
    attr_sec_accessor :default_outline_height,       2
    attr_sec_accessor :default_underline_height,     2
    attr_sec_accessor :default_strikethrough_height, 2
    attr_sec_accessor :default_shadow_color,         'Color.new(0,0,0,100)'
    attr_sec_accessor :default_gradient_color,       'Color.gray'
    attr_sec_accessor :addon_order,       '[:drg_draw_text_shadow,
                                            :drg_draw_text_outline,
                                            :draw_text,
                                            :drg_draw_text_gradient,
                                            :drg_draw_text_underline,
                                            :drg_draw_text_strikethrough]'
    method_defined?(:default_out_color) || (attr_accessor :default_out_color)
    method_defined?(:default_shadow)    || (attr_accessor :default_shadow)
    method_defined?(:default_outline)   || (attr_accessor :default_outline)
    #------------------------------------------------------------------------
    # * Alias Listing
    #------------------------------------------------------------------------
    alias_sec_method :default_outline_color,        :default_out_color
    alias_sec_method :default_outline_color=,       :default_out_color=
    alias_sec_method :default_vertical_gradient,    :default_vert_grad
    alias_sec_method :default_vertical_gradient=,   :default_vert_grad=
    alias_sec_method :default_horizontal_gradient,  :default_horiz_grad
    alias_sec_method :default_horizontal_gradient=, :default_horiz_grad=
  end
  #--------------------------------------------------------------------------
  # * Class Variable Declaration (Edit this configuration)
  #--------------------------------------------------------------------------
  Font.default_underline            = false
  Font.default_strikethrough        = false
  Font.default_shadow               = false
  Font.default_outline              = true
  Font.default_vert_grad            = false
  Font.default_horiz_grad           = false
  Font.default_shadow_height        = 2
  Font.default_outline_height       = 2
  Font.default_underline_height     = 2
  Font.default_strikethrough_height = 2
  Font.default_shadow_color         = Color.new(0, 0, 0, 100)
  Font.default_outline_color        = Color.new(0, 0, 0, 128)
  Font.default_gradient_color       = Color.gray
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor     :underline, :strikethrough
  attr_reader       :vert_grad, :horiz_grad
  attr_sec_accessor :underline_height,     'Font.default_underline_height'
  attr_sec_accessor :strikethrough_height, 'Font.default_strikethrough_height'
  attr_sec_accessor :shadow_color,         'Font.default_shadow_color'
  attr_sec_accessor :shadow_height,        'Font.default_shadow_height'
  attr_sec_accessor :outline_height,       'Font.default_outline_height'
  attr_sec_accessor :gradient_color,       'Font.default_gradient_color'
  method_defined?(:out_color) || (attr_accessor :out_color)
  method_defined?(:shadow)    || (attr_reader :shadow)
  method_defined?(:outline)   || (attr_reader :outline)
  #--------------------------------------------------------------------------
  # * Aliased method: initialize
  #--------------------------------------------------------------------------
  define_pre_alias(:initialize) do
    # Set font settings
    @underline        = Font.default_underline
    @strikethrough    = Font.default_strikethrough
    @shadow           = Font.default_shadow
    @outline          = Font.default_outline
    @vert_grad        = Font.default_vert_grad
    @horiz_grad       = Font.default_horiz_grad
    @out_color        = Font.default_outline_color || Color.black
  end
  #-------------------------------------------------------------------------
  # * Redefined method: shadow=
  #-------------------------------------------------------------------------
  define_sec_method(:shadow=) do |bool|
    @shadow = bool
    @outline = false unless bool == false
  end
  #-------------------------------------------------------------------------
  # * Redefined method: outline=
  #-------------------------------------------------------------------------
  define_sec_method(:outline=) do |bool|
    @shadow = false unless bool == false
    @outline = bool
  end
  #-------------------------------------------------------------------------
  # * New method: vert_grad=
  #-------------------------------------------------------------------------
  define_sec_method(:vert_grad=) do |bool|
    @vert_grad = bool
    @horiz_grad = false unless bool == false
  end
  #-------------------------------------------------------------------------
  # * New method: horiz_grad=
  #-------------------------------------------------------------------------
  define_sec_method(:horiz_grad=) do |bool|
    @vert_grad = false unless bool == false
    @horiz_grad = bool
  end
  #-------------------------------------------------------------------------
  # * Overwriten method: ==
  #-------------------------------------------------------------------------
  unless method_defined?(:grad_s_color)
    def ==(other)
      attr = [:name, :size, :color, :bold, :italic, :underline,
        :strikethrough, :shadow_color, :outline_color,
        :shadow, :outline, :vert_grad, :horiz_grad, :gradient_color]
      attr.each do |var|
        return false if method(var).call != other.method(var).call
      end
      return true
    end
  end
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias_sec_method :outline_color,        :out_color
  alias_sec_method :outline_color=,       :out_color=
  alias_sec_method :vertical_gradient,    :vert_grad
  alias_sec_method :vertical_gradient=,   :vert_grad=
  alias_sec_method :horizontal_gradient,  :horiz_grad
  alias_sec_method :horizontal_gradient=, :horiz_grad=
end

#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
#
#==============================================================================
class Bitmap
  #--------------------------------------------------------------------------
  # * Alias method: draw_text
  #--------------------------------------------------------------------------
  define_third_method(:draw_text,:basic_draw_text) do |*args|
    conditions = {
      :drg_draw_text_shadow        => font.shadow  && !LiTTleDRAgo::VX,
      :drg_draw_text_outline       => font.outline && !LiTTleDRAgo::VXA,
      :drg_draw_text_underline     => font.underline,
      :drg_draw_text_strikethrough => font.strikethrough,
      :drg_draw_text_gradient      => font.vert_grad || font.horiz_grad
    }
    for effect in Font.addon_order
      if effect == :draw_text
        basic_draw_text(*args)
        next
      end
      send(effect, *args) if conditions[effect]
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_positions
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_positions)
    def drg_draw_text_positions(*args)
      if (r = args[0]).is_a?(Rect)
        x, y, w, h, t = r.x, r.y, r.width, r.height, args[1]
        a = (args.size == 3 ? args[2] : 0) || 0
      else
        x, y, w, h, t = args[0], args[1], args[2], args[3], args[4]
        a = (args.size == 6 ? args[5] : 0) || 0
      end
      return x, y, w, h, t, a
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_shadow
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_shadow)
    def drg_draw_text_shadow(*args)
      orig_color = font.color.dup
      self.font.color = self.font.shadow_color
      sa = self.font.shadow_height
      x, y, w, h, t, a = *drg_draw_text_positions(*args)
      basic_draw_text(x + sa, y + sa, w, h, t, a)
      self.font.color = orig_color
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_outline
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_outline)
    def drg_draw_text_outline(*args)
      orig_color = font.color.dup
      self.font.color = self.font.outline_color.dup
      so = self.font.outline_height.abs.round
      self.font.color.alpha /= so if self.font.color.alpha > 0
      x, y, w, h, t, a = *drg_draw_text_positions(*args)
      for i in -so..so
        for j in -so..so
          basic_draw_text(x + i, y + j, w, h, t, a)
        end
      end
      self.font.color = orig_color
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_underline
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_underline)
    def drg_draw_text_underline(*args)
      u_color = self.font.color.dup
      x, y, w, h, t, a = *drg_draw_text_positions(*args)
      ux = x
      uy = y + h / 2 + self.font.size / 3
      if self.font.underline == :full
        uw = w
      else
        uw = text_size(t).width
        ux += a == 1 ? (w / 2 - uw / 2) : a == 2 ? w - uw : 0
      end
      fill_rect(ux, uy, uw, font.underline_height.abs, u_color)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_strikethrough
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_strikethrough)
    def drg_draw_text_strikethrough(*args)
      x, y, w, h, t, a = *drg_draw_text_positions(*args)
      s_color = self.font.color.dup
      sx = x
      sy = y + h / 2
      _h = font.strikethrough_height.abs
      if self.font.strikethrough == :full
        sw = w
      else
        sw = text_size(t).width
        sx += a == 1 ? (w / 2 - sw / 2) : a == 2 ? w - sw : 0
      end
      fill_rect(sx, sy-(_h/2.0).floor, sw, _h, s_color)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: drg_draw_text_gradient
  #--------------------------------------------------------------------------
  unless method_defined?(:drg_draw_text_gradient)
    def drg_draw_text_gradient(*args)
      x, y, w, h, t, a = *drg_draw_text_positions(*args)
      if self.font.vert_grad || self.font.horiz_grad
        dummy = Bitmap.new(w, h)
        dummy.font = font
        dummy.font.vert_grad = false
        dummy.font.horiz_grad = false
        dummy.basic_draw_text(0, 0, w, h, t, a)
        if font.vert_grad
          dummy.v_gradient_pixel_change(dummy.font.color, font.gradient_color)
        else
          dummy.h_gradient_pixel_change(dummy.font.color, font.gradient_color)
        end
        self.blt(x, y, dummy, dummy.rect)
      end
    end
  end
  #-------------------------------------------------------------------------
  # * New method: v_gradient_pixel_change
  #-------------------------------------------------------------------------
  unless method_defined?(:v_gradient_pixel_change)
    def v_gradient_pixel_change(sc = Color.red, ec = Color.blue, r = rect)
      for y_ in (r.y).round...(r.y + r.height).round
        color = Color.color_between(sc, ec, (y_ / (r.height).to_f))
        for x_ in (r.x).round...(r.x + r.width).round
          a = get_pixel(x_, y_).alpha
          next if a == 0
          color.alpha = a
          set_pixel(x_, y_, color)
        end
      end
    end
  end
  #-------------------------------------------------------------------------
  # * New method: h_gradient_pixel_change
  #-------------------------------------------------------------------------
  unless method_defined?(:h_gradient_pixel_change)
    def h_gradient_pixel_change(sc = Color.red, ec = Color.blue, r = rect)
      for x_ in (r.x).round...(r.x + r.width).round
        color = Color.color_between(sc, ec, (x_ / r.width.to_f))
        for y_ in (r.y).round...(r.y + r.height).round
          a = get_pixel(x_, y_).alpha
          next if a == 0
          color.alpha = a
          set_pixel(x_, y_, color)
        end
      end
    end
  end
end

#==============================================================================
# ** Color
#------------------------------------------------------------------------------
#
#==============================================================================
class Color
  #--------------------------------------------------------------------------
  # * Self
  #--------------------------------------------------------------------------
  class << self
    #-------------------------------------------------------------------------
    # * Name      : Color Between
    #   Info      : Gets Color Between Two colors given the percent
    #   Author    : SephirothSpawn
    #   Call Info : Start Color, Finish Color, Percent
    #-------------------------------------------------------------------------
    unless method_defined?(:color_between)
      def color_between(color_a, color_b, percent = 0.5)
        @color_between ||= {}
        key = [color_a, color_b, percent]
        if @color_between.has_key?(key)
          return @color_between[key]
        end
        r = Integer(color_a.red   + (color_b.red   - color_a.red)   * percent)
        g = Integer(color_a.green + (color_b.green - color_a.green) * percent)
        b = Integer(color_a.blue  + (color_b.blue  - color_a.blue)  * percent)
        a = Integer(color_a.alpha + (color_b.alpha - color_a.alpha) * percent)
        @color_between[key] = Color.new(r, g, b, a)
        return @color_between[key]
      end
    end
  end
end