I'm not passing "ff" myself, but it's there as a fallback to process a hex string. Personally I pass integers between 0-255 but other people may want to pass hex strings? If you pass 0xff, ruby will automatically turn it into 255 which is an Integer, and gets processed as such. The reason I have this is for versatility depending on how people want to use it in their own application. Ruby's integers default to base 10, hence the to_i(16). It's taking a string of hex code "ff" and it needs to convert it from base 16 to base 10.

irb(main):067:0> "ff".to_i
=> 0

irb(main):070:0> "ff".to_i(16)
=> 255

The problem I was having initially is that Gosu::Color has a color value of 0xAARRGGBB opposed to individual values for Alpha, Red, Green and Blue. 0xAA, 0xRR, 0xGG, 0xBB. So using what was available to me I process this compounded value as a string, split it, modify it, repack it, and then change the original value.

I'm not really sure how to implement what you posted -- after looking into forwardable I wasn't sure how to make it meet my needs. I'm trying to keep an objects color value separate from a gosu object -- maybe this isn't the correct approach but my UI_Elements don't know anything about gosu, and I was trying to keep it as abstract as possible. For this reason each UI_Element has a @color ranging from 0x0 to 0xffffffff

After much mucking around today, hairs lost and hours of frustration later -- this is my new version of the module without string manipulation:

module Colored
  class Position
    Alpha = 0
    Red = 1
    Green = 2
    Blue = 3
  end
 
  def color=(value)
    if (0x0..0xffffffff).include? value
      breakdown_color(value)
    end
  end
 
  def alpha=(value)
    change_value(Position::Alpha, value)
  end
 
  def red=(value)
    change_value(Position::Red, value)
  end
 
  def green=(value)
    change_value(Position::Green, value)
  end
 
  def blue=(value)
    change_value(Position::Blue, value)
  end
 
  def color
    return @color
  end
 
  def alpha
    return @color_breakdown[Position::Alpha]
  end
 
  def red
    return @color_breakdown[Position::Red]
  end
 
  def green
    return @color_breakdown[Position::Green]
  end
 
  def blue
    return @color_breakdown[Position::Blue]
  end
 
  private
 
  def breakdown_color(value)
    @color = value
   
    remainder = value
    alpha = 0
    red = 0
    green = 0
    blue = 0
    divmod = Array.new(1)
   
    begin
      case remainder
        when (0x0..0xff)
          blue = remainder
          divmod[1] = 0
        when (0x100..0xffff)
          divmod = remainder.divmod(0x100)
          green = divmod[0]
        when (0x10000..0xffffff)
          divmod = remainder.divmod(0x10000)
          red = divmod[0]
        when (0x1000000..0xffffffff)
          divmod = remainder.divmod(0x1000000)
          alpha = divmod[0]
      end
      remainder = divmod[1]
    end until remainder == 0
    @color_breakdown = Array[alpha, red, green, blue]
  end
 
  def change_value(position, value)
    if (0x0..0xff).include? value
      @color_breakdown[position] = value
      update_color
    end
  end
 
  def update_color
    @color = (self.alpha * 0x1000000) +
             (self.red * 0x10000) +
             (self.green * 0x100) +
             (self.blue)
  end
end