Theo - Bitmap Addon v2.0

# =============================================================================
# TheoAllen - Bitmap Extra Addons
# Version : 2.0
# Contact : www.rpgmakerid.com (or) http://theolized.blogspot.com
# (This script documentation is written in informal indonesian language)
# =============================================================================
($imported ||= {})[:Theo_BitmapAddons]=true
# =============================================================================
# CHANGE LOGS:
# -----------------------------------------------------------------------------
# 2013.06.04 - Massive update. Increment to version 2.0
#            - add draw gradient_line
#            - add draw_polygon
#            - add draw_ellipse
#            - etc ....
# 2013.05.21 - Started and Finished script
# =============================================================================
=begin
  # ===========================================================================
  Perkenalan :
  Script ini adalah untuk menggambar bentuk2 dasar dalam class bitmap. Dan ini
  cuman sarana untuk para scripter. Method2 yg wa tambahin yaitu,

  Garis :
  - draw_line
  - gradient_line

  Lingkaran :
  - draw_ellipse
  - draw_circle
  - fill_ellipse
  - fill_circle

  Poligon :
  - draw_shape
  - draw_polygon
  - draw_shape_params
  - fill_polygon
  - fill_shape_params

  class Color :
  - same?(color1[,color2[,color3,...)
  - empty?

  ===========================================================================
  Cara penggunaan :
  ===========================================================================
  Garis :
  ---------------------------------------------------------------------------
  *) bitmap.draw_line(x1,y1,x2,y2[,color])
  *) bitmap.draw_line(x1,y1,x2,y2[,color]) {|coordinate| }

  Untuk ngedraw line dari koordinat (x1,y1) ampe ke koordinat (x2,y2). Jika
  kamu gunain argument block, maka yg dikeluarkan adalah nilai koordinat
  masing2 titik yg digambar dalam bentuk array. misalnya coordinate[0]
  adalah posisi x dan coordinate[1] adalah posisi y.

  Secara default, jika color diabaikan maka warna yg dipake adalah putih
  Color.new(255,255,255)

  *) bitmap.gradient_line(x1,y1,x2,y2,color1,color2)

  Untuk ngedraw line dari koordinat (x1,y1) ampe ke koordinat (x2,y2) dengan
  gradient dari color1 ke color2. Untuk saat ini masi belom support argument
  block

  ---------------------------------------------------------------------------
  Lingkaran :
  ---------------------------------------------------------------------------

  *) bitmap.draw_ellipse(x,y,horz,vert[,color[,think[,step]]])
  Untuk ngedraw gambar poligon dengan argumen sebagai berikut :
  x     >> koordinat x titik pusat
  y     >> koordinat y titik pusat
  horz  >> jari2 horizontal
  vert  >> jari2 vertikal
  color >> warna garisnya (default : putih)
  think >> ketebalan garis (default : 1)
  step  >> jarak antar titik (default : 0.1)

  *) bitmap.draw_circle(x,y,radius[,color[,think[,step]]])
  Untuk ngedraw gambar lingkaran. Argumen sama kek draw ellipse. bedanya cuman
  di radius (jari2) doank

  *) bitmap.fill_ellipse(x,y,horz,vert,color1[,color2[,step]])
  Untuk ngefill ellipse. x,y,horz,vert sama kek yg lainnya. color1 adalah untuk
  outline. Sedangkan color2 untuk fill. Jika color2 ga diisi, maka warnanya
  adalah sama kek color1

  *) bitmap.fill_circle(x,y,radius,color1[,color2[,step]])
  Overall sama juga :v

  ---------------------------------------------------------------------------
  Poligon :
  ---------------------------------------------------------------------------

  *) bitmap.draw_shape(x,y,params,length[,color1[,bone[,fill[,color2])
  Ini adalah method dasar untuk ngedraw poligon. Jadi jangan heran kalo
  argumennya kelewat banyak. Untuk keterangan argumennya sebagai berikut

  x       >> koordinat x titik pusat
  y       >> koordinat y titik pusat
  params  >> parameter dalam array. cnth : [100,50,100,50,100,50]
  length  >> panjang (maksimal)
  color1  >> warna untuk ngedraw garisnya (default : putih)
  bone    >> jika true maka kerangka poligon akan didraw (default : true)
  fill    >> jika true maka poligon akan diisi wanra (default : false)
  color2  >> warna untuk ngefill (default : sama kek color1)

  *) bitmap.draw_polygon(x,y,corner,length,color1[,bone[,color2]])

  Method untuk ngedraw poligon. overall sama kek draw_shape. Hanya saja, corner
  adalah jumlah sudut yg nantinya mau u gambar. Semisal kamu masukin 5, maka
  akan jadi segi lima. Bone secara default true (gambar kerangka). color2 adalah
  warna untuk ngegambar kerangka itu (warna sama kek color1).

  *) bitmap.draw_shape_params(x,y,params,length,color1[,bone[,color2]])

  Method untuk ngedraw parameter (atk,def,int,agi,dll...) dalam bentuk poligon.
  Overall sama kek draw_polygon. Hanya saja berbeda pada argumen params. Contoh
  penggunaannya seperti ini :

  params = [atk,def,matk,mdf,agi,luk]
  bitmap.draw_shape(50,50,params,50,Color.new(0,255,0))

  *) bitmap.fill_polygon(x,y,corner,length,color1[,color2])
  Bikin gambar poligon dan sekalian difill dengan warna. Color1 adalah outline,
  dan color2 adalah fillnya. Jika color2 diabaikan, maka warnanya akan sama
  kek color1

  *) bitmap.fill_shape_params(x,y,params,length,color1[,color2])
  Overall sama kek fill_polygon. Hanya berbeda pada params saja

  ---------------------------------------------------------------------------
  Lain-lain :
  ---------------------------------------------------------------------------
  Wa juga nambahin sesuatu di class Color. Yaitu :

  *) color.same?(color1[,color2[,color3,dst...]]])
  Untuk ngecek apakah komponen warna yg dibandingkan itu sama atau tidak dengan
  methode or

  *) color.empty?
  return true kalo semisal alphanya adalah 0

  ===========================================================================
  Terms of use :
  ---------------------------------------------------------------------------
  Credit gw, TheoAllen dan juga Modern Algebra sebagai inspirator ide ini.
  Script ini hanya digunakan untuk non-komersil, atas dasar yg tertulis dari
  creative common pada link berikut :

  http://creativecommons.org/licenses/by-nc-sa/2.5/ca/

  ===========================================================================
  Special Thanks :
  - Modern Algebra atas ide bitmap addonnya

=end
# =============================================================================
class Bitmap
  attr_accessor :start_degree

  alias theo_bitmap_init initialize
  def initialize(*args)
    theo_bitmap_init(*args)
    @start_degree = 270
  end

  def draw_line(x1,y1,x2,y2,color=Color.new(255,255,255),color_set_skip = false)
    if x1 == x2 && y1 == y2
      set_pixel(x1,y1,color)
      yield [x1,x2] if block_given?
      return
    end
    jarak_x = (x2-x1)
    jarak_y = (y2-y1)
    if jarak_y == 0 || jarak_x == 0
      if jarak_y == 0
        draw_horz(x1,y1,jarak_x,color)
        for j in 0..jarak_x
          yield [x1,y1]
          x1 += 1
        end if block_given?
      elsif jarak_x.abs == 0
        draw_vert(x1,y1,jarak_y,color)
        for k in 0..jarak_y
          yield [x1,y1]
          y1 += 1
        end if block_given?
      end
      return
    end
    maximum = [jarak_x.abs,jarak_y.abs].max
    rasio_x = jarak_x / maximum.to_f
    rasio_y = jarak_y / maximum.to_f
    real_x = x1.to_f
    real_y = y1.to_f
    for i in 0..maximum
      set_pixel(x1,y1,color) unless get_pixel(x1,y1).same?(color) ||
        color_set_skip ? !get_pixel(x1,y1).empty? : false
      real_x += rasio_x
      real_y += rasio_y
      yield [x1,y1] if block_given?
      x1 = real_x.round
      y1 = real_y.round
    end
  end

  def gradient_line(x1,y1,x2,y2,color1 = Color.new(255,255,255),color2 = color1)
    jarak_x = (x2-x1)
    jarak_y = (y2-y1)
    radius = Math.sqrt((jarak_x**2) + (jarak_y**2))
    red_diff = (color2.red - color1.red) / radius
    green_diff = (color2.green - color1.green) / radius
    blue_diff = (color2.blue - color1.blue) / radius
    alpha_diff = (color2.alpha - color1.alpha) / radius
    red = color1.red
    green = color1.green
    blue = color1.blue
    alpha = color1.alpha
    if jarak_y.abs == 0 || jarak_x.abs == 0
      gradient_fill_rect(x1,y1,1,jarak_y,color1,color2,true) if jarak_y.abs == 0
      gradient_fill_rect(x1,y1,jarak_x,1,color1,color2) if jarak_x.abs == 0
      return
    end
    maximum = [jarak_x.abs,jarak_y.abs].max
    rasio_x = jarak_x / maximum.to_f
    rasio_y = jarak_y / maximum.to_f
    real_x = x1.to_f
    real_y = y1.to_f
    for i in 0..maximum
      new_color = Color.new(red,green,blue,alpha)
      set_pixel(x1,y1,new_color) unless get_pixel(x1,y1).same?(new_color)
      real_x += rasio_x
      real_y += rasio_y
      x1 = real_x.round
      y1 = real_y.round
      red += red_diff
      blue += blue_diff
      green += green_diff
      alpha += alpha_diff
    end
  end

  def draw_horz(x,y,width,color = Color.new(255,255,255))
    if width < 0
      fill_rect(x+width+1,y,width.abs,1,color)
      return
    end
    fill_rect(x,y,width,1,color)
  end

  def draw_vert(x,y,height,color = Color.new(255,255,255))
    if height < 0
      fill_rect(x,y+height+1,1,height.abs,color)
      return
    end
    fill_rect(x,y,1,height,color)
  end

  def draw_ellipse(x,y=0,horz=1,vert=1,color=Color.new(255,255,255),think=1,
      step=0.1)
    return if think < 1
    ori_x = x
    ori_y = y
    x += horz
    degree = 0.0
    while degree <= 360
      yield [x,y] if block_given?
      set_pixel(x,y,color) unless get_pixel(x,y).same?(color)
      x = Math.cos(Math.radian(degree)) * horz + ori_x
      y = Math.sin(Math.radian(degree)) * vert + ori_y
      degree = [degree+step,361].min
    end
    if think > 1
      draw_ellipse(ori_x+1,ori_y+1,horz,vert,think-1,color,step)
      draw_ellipse(ori_x-1,ori_y-1,horz,vert,think-1,color,step)
      draw_ellipse(ori_x+1,ori_y-1,horz,vert,think-1,color,step)
      draw_ellipse(ori_x-1,ori_y+1,horz,vert,think-1,color,step)
    end
  end

  def draw_circle(x,y,radius,color=Color.new(255,255,255),think=1)
    draw_ellipse(x,y,radius,radius,think,color) {|coordinate|
      yield coordinate if block_given?
    }
  end

  def fill_circle(x,y,radius,color1,color2=color1,step=0.1)
    fill_ellipse(x,y,radius,radius,color1,color2,step)
  end

  def fill_ellipse(x,y,horz,vert,color1,color2=color1,step=0.1)
    draw_ellipse(x,y,horz,vert,1,color1,0.5) {|cor|
      draw_line(x,y,cor[0],cor[1],color2,true)
    }
    for i in 0..1
      for baris in 0..horz*2
        for kolom in 0..vert*2
          pos_x = baris-horz+x
          pos_y = kolom-vert+y
          syarat = (get_pixel(pos_x+1,pos_y).same?(color1,color2) &&
          get_pixel(pos_x-1,pos_y).same?(color1,color2)) ||
          (get_pixel(pos_x,pos_y-1).same?(color1,color2) &&
          get_pixel(pos_x,pos_y+1).same?(color1,color2)) ||
          (get_pixel(pos_x+1,pos_y+1).same?(color1,color2) &&
          get_pixel(pos_x-1,pos_y-1).same?(color1,color2)) ||
          (get_pixel(pos_x-1,pos_y+1).same?(color1,color2) &&
          get_pixel(pos_x+1,pos_y-1).same?(color1,color2))
          if syarat && !get_pixel(pos_x,pos_y).same?(color1,color2)
            set_pixel(pos_x,pos_y,color2)
          end
        end
      end
    end
  end

  def draw_polygon(x,y,corner,length,color1,bone=true,color2=color1)
    return unless corner.is_a?(Numeric)
    draw_shape(x,y,Array.new(corner){1},length,color1,bone,false,color2)
  end

  def fill_polygon(x,y,corner,length,color1,color2=color1)
    return unless corner.is_a?(Numeric)
    draw_shape(x,y,Array.new(corner),length,color1,false,true,color2)
  end

  def draw_shape_params(x,y,params,length,color1,bone=true,color2=color1)
    draw_shape(x,y,params,length,color1,bone,false,color2)
  end

  def fill_shape_params(x,y,params,length,color1,color2=color1)
    draw_shape(x,y,params,length,color1,false,true,color2)
  end

  def draw_shape(x,y,params,length,color1 = Color.new(255,255,255),
      include_bone = true ,fill=false,color2 = color1)
    return unless params.is_a?(Array)
    return unless params.size >= 3
    degree_plus = 360 / params.size
    degree = @start_degree
    coordinate = []
    edge = []
    params.each do |i|
      x_des = x + Math.cos(Math.radian(degree)) * (length*(i.to_f/params.max))
      y_des = y + Math.sin(Math.radian(degree)) * (length*(i.to_f/params.max))
      draw_line(x,y,x_des,y_des,color2) if include_bone
      degree += degree_plus
      coordinate.push(Coordinate.new(x_des,y_des))
    end
    for i in -1..coordinate.size-2
      c = coordinate
      draw_line(c[i].x,c[i].y,c[i+1].x,c[i+1].y,color1) {|cor| edge.push(cor)}
    end
    return unless fill
    edge.each do |line|
      draw_line(x,y,line[0],line[1],color2,true)
    end
    for i in 0..1
      for baris in 0..length*2
        for kolom in 0..length*2
          pos_x = baris-length+x
          pos_y = kolom-length+y
          syarat = (get_pixel(pos_x+1,pos_y).same?(color1,color2) &&
          get_pixel(pos_x-1,pos_y).same?(color1,color2)) ||
          (get_pixel(pos_x,pos_y-1).same?(color1,color2) &&
          get_pixel(pos_x,pos_y+1).same?(color1,color2)) ||
          (get_pixel(pos_x+1,pos_y+1).same?(color1,color2) &&
          get_pixel(pos_x-1,pos_y-1).same?(color1,color2)) ||
          (get_pixel(pos_x-1,pos_y+1).same?(color1,color2) &&
          get_pixel(pos_x+1,pos_y-1).same?(color1,color2))
          if syarat && !get_pixel(pos_x,pos_y).same?(color1,color2)
            set_pixel(pos_x,pos_y,color2)
          end
        end
      end
    end
  end

end

class Coordinate
  attr_accessor :x,:y

  def initialize(x,y)
    @x = x
    @y = y
  end

end

module Math

  def self.radian(degree)
    return (degree.to_f/180) * Math::PI
  end

  def self.degree(radian)
    return (radian.to_f/Math::PI) * 180
  end

end

class Color

  def same?(*args)
    return false unless args.all? {|c| c.is_a?(Color)}
    return args.any?{|color| self.red == color.red &&
      self.green == color.green && self.blue == color.blue &&
      self.alpha == color.alpha}
  end

  def empty?
    return self.alpha <= 0
  end

end