API tools faq
paste
mcgluszak

[Author: Caesar] Caesar's Graphics Toolkit

mcgluszak
Jul 31st, 2011
137
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Ruby 33.94 KB | None | 0 0
raw download clone embed print report
  1. #/////////////////////Caesar's Graphics Toolkit///////////////////////
  2. #~~~~~~~~~~~~~~~~by Caesar~~~~~~~~~~~~~~~~
  3. #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  4. #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  5. # Das CGT enthält viele nßtzliche Methoden, die der
  6. # Verbesserung, der Vereinfachung und der Erweiterung
  7. # der Grafikverarbeitung dienen.
  8. #<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  9.  
  10. class Bitmap
  11.   #>>>>>>>>>>>>>>>>>>>
  12.   # Mit dem DDA-Algorithmus (Digital Differential Analyzer)
  13.   # werden zwei Punkte (x1, y1) und (x2, y2) miteineander
  14.   # verbunden.
  15.   # -- color: Farbe
  16.   # -- stroke (1): Linienstärke
  17.   #<<<<<<<<<<<<<<<<<<<
  18.   def draw_line(x1, y1, x2, y2, color, stroke=1)
  19.     return if stroke <= 0
  20.     if x2 < x1
  21.       temp = x2
  22.       x2 = x1
  23.       x1 = temp
  24.       temp = y2
  25.       y2 = y1
  26.       y1 = temp
  27.     end
  28.     length = x2-x1
  29.     length = Math.abs(y2-y1) if length < Math.abs(y2-y1)
  30.     x_increment =(x2-x1).to_f / length
  31.     y_increment = (y2-y1).to_f / length
  32.     x = x1
  33.     y = y1
  34.     s = stroke.to_f / 2
  35.     if x == x2
  36.       fill_rect(x-s, [y1, y2].min, s+s, Math.abs(y2-y1), color)
  37.     end
  38.     while x < x2
  39.       fill_rect(x-s, y-s, s+s, s+s, color)
  40.       x += x_increment
  41.       y += y_increment
  42.     end
  43.   end
  44.   #--------------
  45.   #>>>>>>>>>>>>>>>>>>>
  46.   # Mit dem Bresenham-Algorithmus wird ein Kreis um den Mittelpunkt
  47.   # (cx, cy) gezeichnet.
  48.   # -- radius: Radius
  49.   # -- color: Farbe
  50.   # -- stroke (1): Linienstärke
  51.   #<<<<<<<<<<<<<<<<<<<
  52.   def draw_circle(cx, cy, radius, color, stroke=1)
  53.     return if stroke <= 0
  54.     x = 0
  55.     y = radius
  56.     d = radius-1
  57.     while y >= x
  58.       s = stroke.to_f / 2
  59.       fill_rect(cx+x-s, cy+y-s, s+s, s+s, color) # footprints
  60.       fill_rect(cx+x-s, cy-y-s, s+s, s+s, color)
  61.       fill_rect(cx-x-s, cy+y-s, s+s, s+s, color)
  62.       fill_rect(cx-x-s, cy-y-s, s+s, s+s, color)
  63.       fill_rect(cx+y-s, cy+x-s, s+s, s+s, color)
  64.       fill_rect(cx-y-s, cy+x-s, s+s, s+s, color)
  65.       fill_rect(cx+y-s, cy-x-s, s+s, s+s, color)
  66.       fill_rect(cx-y-s, cy-x-s, s+s, s+s, color)
  67.       return if y == x
  68.       if d < 0
  69.         d += 2*x + 3
  70.       else
  71.         y -= 1
  72.         d += 2*x - 2*y + 5
  73.       end
  74.       x += 1
  75.     end
  76.   end
  77.   #--------------
  78.   #>>>>>>>>>>>>>>>>>>>>
  79.   # Zeichnet einen gefĂźllten Kreis um den Mittelpunkt (cxcy).
  80.   # -- radius: Radius
  81.   # -- color: Farbe
  82.   #<<<<<<<<<<<<<<<<<<
  83.   def fill_circle(cx, cy, radius, color)
  84.     x = 0
  85.     y = radius
  86.     d = radius-1
  87.     while y >= x
  88.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  89.       fill_rect(cx-y, cy-x, 2*y, 1, color)
  90.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  91.       fill_rect(cx-y, cy+x, 2*y, 1, color)
  92.       return if y == x
  93.       if d < 0
  94.         d += 2*x + 3
  95.       else
  96.         y -= 1
  97.         d += 2*x - 2*y + 5
  98.       end
  99.       x += 1
  100.     end
  101.   end
  102.   #--------------
  103.   #>>>>>>>>>>>>>>>>>>>
  104.   # Zeichnet eine Ellipse um den Mittelpunkt (cx, cy) mit den Radien
  105.   # a und b.
  106.   # -- color: Farbe
  107.   # -- stroke (1): Linienstärke
  108.   #<<<<<<<<<<<<<<<<<<<
  109.   def draw_ellipse(cx, cy, a, b, color, stroke=1)
  110.     return if stroke <= 0
  111.     x = 0
  112.     y = b
  113.     d1 = b*b-a*a*b-(a*a.to_f/4)
  114.     ellipse_footprints(cx, cy, x, y, color, stroke)
  115.     while( a*a*(y-0.5) > b*b*(x-1))
  116.       if d1 < 0
  117.         d1 += b*b*(2*x+3)
  118.       else
  119.         d1 += (b*b*(2*x+3)+a*a*(-2*y+2))
  120.         y -= 1
  121.       end
  122.       x += 1
  123.       ellipse_footprints(cx, cy, x, y, color, stroke)
  124.     end
  125.     d2 = b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b
  126.     while(y > 0)
  127.       if d2 < 0
  128.         d2 += b*b*(2*x+2)+a*a*(-2*y+3)
  129.         x += 1
  130.       else
  131.         d2 += a*a*(-2*y+3)
  132.       end
  133.       y -= 1
  134.       ellipse_footprints(cx, cy, x, y, color, stroke)
  135.     end
  136.   end
  137.   #----
  138.   def ellipse_footprints(cx, cy, x, y, color, stroke=1)
  139.     s = stroke.to_f / 2
  140.     fill_rect(cx+x-s, cy+y-s, s+s, s+s, color)
  141.     fill_rect(cx+x-s, cy-y-s, s+s, s+s, color)
  142.     fill_rect(cx-x-s, cy+y-s, s+s, s+s, color)
  143.     fill_rect(cx-x-s, cy-y-s, s+s, s+s, color)
  144.   end
  145.   #--------------
  146.   #>>>>>>>>>>>>>>>>>>>
  147.   # Zeichnet eine gefĂźllte Ellipse um den Mittelpunkt (cx, cy) mit den
  148.   # Radien a und b.
  149.   # -- color: Farbe
  150.   #<<<<<<<<<<<<<<<<<<<
  151.   def fill_ellipse(cx, cy, a, b, color)
  152.     x = 0
  153.     y = b
  154.     d1 = b*b-a*a*b-(a*a.to_f/4)
  155.     fill_rect(cx-x, cy-y, 2*x, 1, color)
  156.     fill_rect(cx-x, cy+y, 2*x, 1, color)
  157.     while( a*a*(y-0.5) > b*b*(x-1))
  158.       if d1 < 0
  159.         d1 += b*b*(2*x+3)
  160.       else
  161.         d1 += (b*b*(2*x+3)+a*a*(-2*y+2))
  162.         y -= 1
  163.       end
  164.       x += 1
  165.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  166.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  167.     end
  168.     d2 = b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b
  169.     while(y > 0)
  170.       if d2 < 0
  171.         d2 += b*b*(2*x+2)+a*a*(-2*y+3)
  172.         x += 1
  173.       else
  174.         d2 += a*a*(-2*y+3)
  175.       end
  176.       y -= 1
  177.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  178.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  179.     end
  180.   end
  181.   #--------------
  182.   #>>>>>>>>>>>>>>>>>>>
  183.   # Zeichnet den Kreis oder die Ellipse, die dem Rechteck
  184.   # einbeschrieben ist.
  185.   # -- x, y, width, height: Rechteck
  186.   # -- color: Farbe
  187.   # -- stroke (1): Linienstärke
  188.   #<<<<<<<<<<<<<<<<<<<
  189.   def draw_oval(x, y, width, height, color, stroke=1)
  190.     if width == height
  191.       return draw_circle(x + width/2, y + height/2, width/2, color, stroke)
  192.     end
  193.     draw_ellipse(x + width/2, y + height/2, width/2, height/2, color, stroke)
  194.   end
  195.   #--------------
  196.   #>>>>>>>>>>>>>>>>>>>
  197.   # Zeichnet den Kreis oder die Ellipse, die dem Rechteck
  198.   # einbeschrieben ist, gefĂźllt.
  199.   # -- x, y, width, height: Rechteck
  200.   # -- color: Farbe
  201.   #<<<<<<<<<<<<<<<<<<<
  202.   def fill_oval(x, y, width, height, color)
  203.     return fill_circle(x + width/2, y + height/2, width/2, color) if width == height
  204.     fill_ellipse(x + width/2, y + height/2, width/2, height/2, color)
  205.   end
  206.   #--------------
  207.   #>>>>>>>>>>>>>>>>>>>
  208.   # Zeichent ein Rechteck.
  209.   # -- x, y, width, height: Rechteck
  210.   # -- color: Farbe
  211.   # -- stroke (1): Linienstärke
  212.   #<<<<<<<<<<<<<<<<<<<
  213.   def draw_rect(x, y, width, height, color, stroke=1)
  214.     return if stroke <= 0
  215.     #~~~~~rekursiv~~~~~
  216.     #fill_rect(x, y, width, 1, color)
  217.     #fill_rect(x, y, 1, height, color)
  218.     #fill_rect(x+width-1, y, 1, height, color)
  219.     #fill_rect(x, y+height-1, width, 1, color)
  220.     #draw_rect(x+1, y+1, width-2, height-2, color, stroke-1)
  221.     #~~~~nicht rekursiv~~~~
  222.     fill_rect(x, y, width, stroke, color)
  223.     fill_rect(x, y, stroke, height, color)
  224.     fill_rect(x+width-stroke, y, stroke, height, color)
  225.     fill_rect(x, y+height-stroke, width, stroke, color)
  226.   end
  227.   #-------------
  228.   #>>>>>>>>>>>>>>>>>>>
  229.   # Zeichnet ein Rechteck mit einem speziellen "3D-Effekt".
  230.   # -- x, y, width, height: Rechteck
  231.   # -- color: Farbe
  232.   # -- raised (true): gibt an, ob das Rechteck hĂśher (true) oder tiefer (false)
  233.   #     gezeichnet wird.
  234.   # -- stroke (1): Linienstärke
  235.   #<<<<<<<<<<<<<<<<<<<
  236.   def draw_3d_rect(x, y, width, height, color, raised=true, stroke=1)
  237.     return if stroke <= 0
  238.     if raised
  239.       color1 = color.brighter
  240.       color2 = color.darker
  241.     else
  242.       color1 = color.darker
  243.       color2 = color.brighter
  244.     end
  245.     fill_rect(x, y, width, 1, color1)
  246.     fill_rect(x, y, 1, height, color1)
  247.     fill_rect(x+width-1, y, 1, height, color2)
  248.     fill_rect(x, y+height-1, width, 1, color2)
  249.     draw_3d_rect(x+1, y+1, width-2, height-2, color, raised, stroke-1)
  250.   end
  251.   #---------------
  252.   #>>>>>>>>>>>>>>>>>>>
  253.   # Zeichnet ein dickes Rechteck mit einem FarbĂźbergang von außen
  254.   # nach innen.
  255.   # -- x, y, width, height: Rechteck
  256.   # -- color: Farbe außen
  257.   # -- stroke (3): Linienstärke
  258.   # -- brighter (true): FarbĂźbergang nach innen heller (true) oder dunkler (false)
  259.   #<<<<<<<<<<<<<<<<<<<
  260.   def draw_frame_rect(x, y, width, height, color, stroke=3, brighter=true)
  261.     return if stroke <= 0
  262.     fill_rect(x, y, width, 1, color)
  263.     fill_rect(x, y, 1, height, color)
  264.     fill_rect(x+width-1, y, 1, height, color)
  265.     fill_rect(x, y+height-1, width, 1, color)
  266.     next_color = brighter ? color.brighter : color.darker
  267.     draw_frame_rect(x+1, y+1, width-2, height-2, next_color, stroke-1, brighter)
  268.   end
  269.   #---------------
  270.   #>>>>>>>>>>>>>>>>>>>
  271.   # Zeichnet ein Rechteck mit abgerundeten Ecken.
  272.   # -- x, y, width, height: Rechteck
  273.   # -- b: gibt an, wie rund die Ecken sind (Radius der Viertelkreise an den Ecken)
  274.   # -- color: Farbe
  275.   # -- stroke (1): Linienstärke
  276.   #<<<<<<<<<<<<<<<<<<<
  277.   def draw_round_rect(x, y, width, height, b, color, stroke=1)
  278.     fill_rect(x+b, y, width-b-b, stroke, color)
  279.     fill_rect(x, y+b, stroke, height-b-b, color)
  280.     fill_rect(x+width-stroke, y+b, stroke, height-b-b, color)
  281.     fill_rect(x+b, y+height-stroke, width-b-b, stroke, color)
  282.     circle = Bitmap.new(b+b, b+b)
  283.     circle.draw_oval(0, 0, b+b, b+b, color, stroke)
  284.     blt(x, y, circle.area(0, 0, b, b), Rect.new(0, 0, b, b))
  285.     blt(x+width-b, y, circle.area(b, 0, b, b), Rect.new(0, 0, b, b))
  286.     blt(x+width-b, y+height-b, circle.area(b, b, b, b), Rect.new(0, 0, b, b))
  287.     blt(x, y+height-b, circle.area(0, b, b, b), Rect.new(0, 0, b, b))
  288.   end
  289.   #---------------
  290.   #>>>>>>>>>>>>>>>>>>>
  291.   # Zeichnet ein gefĂźlltes Rechteck mit abgerundeten Ecken.
  292.   # -- x, y, width, height: Rechteck
  293.   # -- b: gibt an, wie rund die Ecken sind (Radius der Viertelkreise an den Ecken)
  294.   # -- color: Farbe
  295.   # -- stroke (1): Linienstärke
  296.   #<<<<<<<<<<<<<<<<<<<
  297.   def fill_round_rect(x, y, width, height, b, color)
  298.     fill_rect(x, y+b, width, height-b-b, color)
  299.     fill_rect(x+b, y, width-b-b, b, color)
  300.     fill_rect(x+b, y+height-b, width-b-b, b, color)
  301.     circle = Bitmap.new(b+b, b+b)
  302.     circle.fill_oval(0, 0, b+b, b+b, color)
  303.     blt(x, y, circle.area(0, 0, b, b), Rect.new(0, 0, b, b))
  304.     blt(x+width-b, y, circle.area(b, 0, b, b), Rect.new(0, 0, b, b))
  305.     blt(x+width-b, y+height-b, circle.area(b, b, b, b), Rect.new(0, 0, b, b))
  306.     blt(x, y+height-b, circle.area(0, b, b, b), Rect.new(0, 0, b, b))
  307.   end
  308.   #---------------
  309.   #>>>>>>>>>>>>>>>>>>>
  310.   # Zeichnet ein Polygon (Vieleck).
  311.   # -- color: Farbe
  312.   # -- stroke: Linienstärke
  313.   # -- *vertices: Eckpunkte als Arrays der Größe 2 fĂźr x- und y-Koordinaten
  314.   # Ein Aufruf der Methode kĂśnnte z.B. so aussehen:
  315.   # draw_polygon(Color.black, 2, [0, 0], [30, 10], [300, 100], [200, 40], [30, 50])
  316.   #<<<<<<<<<<<<<<<<<<<
  317.   def draw_polygon(color, stroke, *vertices)
  318.     if vertices[0].size > 2
  319.       vertices = vertices[0]
  320.     end
  321.     return if stroke <= 0 or vertices.size <= 2
  322.     count = vertices.size
  323.     for i in -1..count-2
  324.       x1, y1 = vertices[i]
  325.       x2, y2 = vertices[i+1]
  326.       draw_line(x1, y1, x2, y2, color, stroke)
  327.     end
  328.   end
  329.   #---------------
  330.   # todo: gefĂźlltes Polygon zeichnen, ich habe keinen effezienten Algorithmus
  331.   # finden kĂśnnen.
  332.   #---------------
  333.   #>>>>>>>>>>>>>>>>>>>
  334.   # Zeichnet ein regelmäßiges Vieleck um den Mittelpunkt (cx, cy).
  335.   # -- n: Anzahl der Ecken
  336.   # -- radius: Radius
  337.   # -- color: Farbe
  338.   # -- stroke (1): Linienstärke
  339.   #<<<<<<<<<<<<<<<<<<<
  340.   def draw_regular_polygon(cx, cy, n, radius, color, stroke=1)
  341.     return if stroke <= 0 or n <= 2
  342.     phi  = 0
  343.     dphi = 2 * Math::PI / n
  344.     vertices = []
  345.     n.times do
  346.       x = radius*Math.cos(phi) + cx
  347.       y = radius*Math.sin(phi) + cy
  348.       vertices.push([x.to_i, y.to_i])
  349.       phi += dphi
  350.     end
  351.     draw_polygon(color, stroke, vertices)
  352.   end
  353.   #---------------
  354.   #>>>>>>>>>>>>>>>>>>>
  355.   # Zeichnet einen Text mit einem netten Schatteneffekt.
  356.   # -- x, y, width, height: Rechteck
  357.   # -- str: Text
  358.   # -- align (0): Ausrichtung, 0 = linksbĂźndig, 1 = zentriert, 2 = rechtsbĂźndig
  359.   #<<<<<<<<<<<<<<<<<<<
  360.   def draw_shadow_text(x, y, width, height, str, align=0)
  361.     color = font.color.dup
  362.     font.color = Color.new(192, 192, 192, 156)
  363.     draw_text(x+2, y+2, width, height, str, align)
  364.     font.color = color
  365.     draw_text(x, y, width, height, str, align)
  366.   end
  367.   #-------------
  368.   #>>>>>>>>>>>>>>>>>>>
  369.   # Gibt die Bitmap vertikal gespiegelt zurĂźck.
  370.   #<<<<<<<<<<<<<<<<<<<
  371.   def vertical_flip
  372.     buffer = Bitmap.new(width, height)
  373.     for x in 0..width
  374.       for y in 0..height
  375.         pixel = get_pixel(x, y)
  376.         buffer.set_pixel(x, height-y, pixel)
  377.       end
  378.     end
  379.     return buffer
  380.   end
  381.   #-------------
  382.   #>>>>>>>>>>>>>>>>>>
  383.   # Spiegelt die Bitmap vertikal.
  384.   #<<<<<<<<<<<<<<<<<<
  385.   def vertical_flip!
  386.     buffer = vertical_flip
  387.     clear
  388.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  389.   end
  390.   #-------------
  391.   #>>>>>>>>>>>>>>>>>>>
  392.   # Gibt die Bitmap horizontal gespiegelt zurĂźck.
  393.   #<<<<<<<<<<<<<<<<<<<
  394.   def horizontal_flip
  395.     buffer = Bitmap.new(width, height)
  396.     for x in 0..width
  397.       for y in 0..height
  398.         pixel = get_pixel(x, y)
  399.         buffer.set_pixel(width-x, y, pixel)
  400.       end
  401.     end
  402.     return buffer
  403.   end
  404.   #-------------
  405.   #>>>>>>>>>>>>>>>>>>
  406.   # Spiegelt die Bitmap horizontal.
  407.   #<<<<<<<<<<<<<<<<<<
  408.   def horizontal_flip!
  409.     buffer = horizontal_flip
  410.     clear
  411.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  412.   end
  413.   #-------------
  414.   #>>>>>>>>>>>>>>>>>>>
  415.   # Gibt das Negativ der Bitmap, d.h. mit allen Farben umgekehrt, zurĂźck.
  416.   #<<<<<<<<<<<<<<<<<<<
  417.   def negative
  418.     # Look Up Table
  419.     lut = Array.new(256)
  420.     for i in 0..255
  421.       lut[i] = i ^ 255
  422.     end
  423.     #:::::
  424.     buffer = Bitmap.new(width, height)
  425.     for x in 0..width
  426.       for y in 0..height
  427.         px = get_pixel(x, y)
  428.         pixel = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  429.         buffer.set_pixel(x, y, pixel)
  430.       end
  431.     end
  432.     return buffer
  433.   end
  434.   #-------------
  435.   #>>>>>>>>>>>>>>>>>>>
  436.   # Kehrt alle Farbwerte um.
  437.   #<<<<<<<<<<<<<<<<<<<
  438.   def negative!
  439.     buffer = negative
  440.     clear
  441.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  442.   end
  443.   #-------------
  444.   #>>>>>>>>>>>>>>>>>>>>
  445.   # Gibt das Graustufenbild der Bitmap zurĂźck, d.h. die Farbe jedes
  446.   # Pixels wird auf den Mittelwert seiner RGB-Werte gesetzt.
  447.   #<<<<<<<<<<<<<<<<<<<<
  448.   def grayscale
  449.     buffer = Bitmap.new(width, height)
  450.     for x in 0..width
  451.       for y in 0..height
  452.         color = get_pixel(x, y).grayscale
  453.         buffer.set_pixel(x, y, color)
  454.       end
  455.     end
  456.     return buffer
  457.   end
  458.   #-------------
  459.   #>>>>>>>>>>>>>>>>>>>
  460.   # Konvertiert die Bitmap zum Graustufenbild.
  461.   #<<<<<<<<<<<<<<<<<<<
  462.   def grayscale!
  463.     buffer = grayscale
  464.     clear
  465.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  466.   end
  467.   #-------------
  468.   #>>>>>>>>>>>>>>>>>>>
  469.   # Gibt die Bitmap verpixelt zurĂźck, d.h. Quadrate von factor * factor
  470.   # pixels werden zu ihrem Durchschnitt zusammengefasst.
  471.   #<<<<<<<<<<<<<<<<<<<
  472.   def pixelize(factor=2)
  473.     return dup if factor <= 1
  474.     #return scale(1.to_f/factor).scale(factor)
  475.     buffer = Bitmap.new(width, height)
  476.     for ix in 0..width/factor
  477.       for iy in 0..height/factor
  478.         x = ix*factor
  479.         y = iy*factor
  480.         color = average_color(x, y, factor, factor)
  481.         buffer.fill_rect(x, y, factor, factor, color)
  482.       end
  483.     end
  484.     return buffer
  485.   end
  486.   #-------------
  487.   #>>>>>>>>>>>>>>>>>>>
  488.   # Verpixelt die Bitmap.
  489.   #<<<<<<<<<<<<<<<<<<<
  490.   def pixelize!(factor=2)
  491.     buffer = pixelize(factor)
  492.     clear
  493.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  494.   end
  495.   #-------------
  496.   #>>>>>>>>>>>>>>>>>>>
  497.   # Gibt die Bitmap verwaschen zurĂźck. Der Algorithmus ist nicht sehr
  498.   # effezient. Wäre gut, wenn jemand noch einen besseren fände.
  499.   #<<<<<<<<<<<<<<<<<<<
  500.   def blur(f=1)
  501.     buffer = Bitmap.new(width, height)
  502.     for x in 0..width
  503.       for y in 0..height
  504.         color = average_color(x-f, y-f, 2*f, 2*f)
  505.         buffer.set_pixel(x, y, color)
  506.       end
  507.     end
  508.     return buffer
  509.   end
  510.   #-------------
  511.   #>>>>>>>>>>>>>>>>>>>
  512.   # Verwäscht die Bitmap.
  513.   #<<<<<<<<<<<<<<<<<<<
  514.   def blur!(f=1)
  515.     buffer = blur(f)
  516.     clear
  517.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  518.   end
  519.   #-------------
  520.   #>>>>>>>>>>>>>>>>>>>
  521.   # Gibt die Bitmap "geschĂźttelt", d.h. mehrmals Ăźbereinander
  522.   # mit verringer Opacity gezeichnet, zurĂźck.
  523.   #<<<<<<<<<<<<<<<<<<<
  524.   def shake(d=1, horizontal=true, vertical=true)
  525.     return dup if d <= 0 or (! horizontal and ! vertical)
  526.     buffer = Bitmap.new(width, height)
  527.     if horizontal and vertical
  528.       buffer.blt(-d, -d, self, Rect.new(0, 0, width, height), 64)
  529.       buffer.blt(d, -d, self, Rect.new(0, 0, width, height), 64)
  530.       buffer.blt(-d, d, self, Rect.new(0, 0, width, height), 64)
  531.       buffer.blt(d, d, self, Rect.new(0, 0, width, height), 64)
  532.     elsif horizontal
  533.       buffer.blt(-d, 0, self, Rect.new(0, 0, width, height), 128)
  534.       buffer.blt(d, 0, self, Rect.new(0, 0, width, height), 128)
  535.     elsif vertical
  536.       buffer.blt(0, -d, self, Rect.new(0, 0, width, height), 128)
  537.       buffer.blt(0, d, self, Rect.new(0, 0, width, height), 128)
  538.     end
  539.     return buffer
  540.   end
  541.   #-------------
  542.   #>>>>>>>>>>>>>>>>>>>
  543.   # "SchĂźttelt" die Bitmap.
  544.   #<<<<<<<<<<<<<<<<<<<
  545.   def shake!(d=1, horizontal=true, vertical=true)
  546.     buffer = shake(d, horizontal, vertical)
  547.     clear
  548.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  549.   end
  550.   #-------------
  551.   #>>>>>>>>>>>>>>>>>>>
  552.   # Ändert die Helligkeit der Bitmap.
  553.   # -- b: die Helligkeit, muss zwischen -255 (ganz schwarz)
  554.   #     und +255 (ganz weiß) liegen.
  555.   #<<<<<<<<<<<<<<<<<<<
  556.   def change_brightness(b)
  557.     b = [[-255, b].max, 255].min
  558.     # Look Up Table
  559.     lut = Array.new(256)
  560.     for i in 0..255
  561.       if b >= 0
  562.         c = (255 - i) * (b.to_f/255) + i
  563.       else
  564.         c = i * ((255+b.to_f) / 255)
  565.       end
  566.       lut[i] = c
  567.     end
  568.     #::::::::::
  569.     for x in 0..width
  570.       for y in 0..height
  571.         px = get_pixel(x, y)
  572.         color = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  573.         set_pixel(x, y, color)
  574.       end
  575.     end
  576.   end
  577.   #-------------
  578.   #>>>>>>>>>>>>>>>>>>>
  579.   # Verändert den Kontrast.
  580.   # -- contrast: der Parameter muss zwischen -127 und +127 liegen
  581.   #<<<<<<<<<<<<<<<<<<<
  582.   def change_contrast(contrast)
  583.     # LUT
  584.     lut = Array.new(256)
  585.     for i in 0..255
  586.       c = (i - 127 )*((contrast+127).to_f / 127) + 127
  587.       c = [[0, c].max, 255].min
  588.       lut[i] = c
  589.     end
  590.     #::::
  591.     for x in 0..width-1
  592.       for y in 0..height-1
  593.         px = get_pixel(x, y)
  594.         color = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  595.         set_pixel(x, y, color)
  596.       end
  597.     end
  598.   end
  599.   #-------------
  600.   #>>>>>>>>>>>>>>>>>>>
  601.   # Mit dem Threshold-Algorithmus wird ein Schwarz-Weiß-Bild erzeugt.
  602.   # -- s (128): fĂźr jedes Pixel wird der Mittelwert der RGB-Werte gebildet, liegt
  603.   #     er unterhalb des Grenzwertes s, wird das Pixel schwarz, ansonsten weiß.
  604.   #<<<<<<<<<<<<<<<<<<<
  605.   def threshold(s=128)
  606.     buffer = Bitmap.new(width, height)
  607.     for x in 0..width-1
  608.       for y in 0..height-1
  609.         px = get_pixel(x, y)
  610.         b = px.red + px.green + px.blue
  611.         color = b < 3*s ? Color.black(px.alpha) : Color.white(px.alpha)
  612.         buffer.set_pixel(x, y, color)
  613.       end
  614.     end
  615.     return buffer
  616.   end
  617.   #-------------
  618.   #>>>>>>>>>>>>>>>>>>>
  619.   # Konvertiert die Bitmap nach Schwarz-Weiß mit dem Threshold-Algorithmus.
  620.   # -- s (128): fĂźr jedes Pixel wird der Mittelwert der RGB-Werte gebildet, liegt
  621.   #     er unterhalb des Grenzwertes s, wird das Pixel schwarz, ansonsten weiß.
  622.   #<<<<<<<<<<<<<<<<<<<
  623.   def threshold!(s=128)
  624.     buffer = threshold(s)
  625.     clear
  626.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  627.   end
  628.   #-------------
  629.   # Gibt die Bitmap "geprägt", als Relief, zurĂźck.
  630.   #<<<<<<<<<<<<<<<<<<<
  631.   def emboss
  632.     buffer = Bitmap.new(width, height)
  633.     for x in 0..width-1
  634.       for y in 0..height-1
  635.         px = get_pixel(x, y)
  636.         c = (px.average - get_pixel(x+1, y+1).average) + 128
  637.         color = Color.new(c, c, c, px.alpha)
  638.         buffer.set_pixel(x, y, color)
  639.       end
  640.     end
  641.     return buffer
  642.   end
  643.   #-------------
  644.   #>>>>>>>>>>>>>>>>>>>
  645.   # "Prägt" die Bitmap, eine Art Relief wird erzeugt.
  646.   #<<<<<<<<<<<<<<<<<<<
  647.   def emboss!
  648.     buffer = emboss
  649.     clear
  650.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  651.   end
  652.   #-------------
  653.   #>>>>>>>>>>>>>>>>>>>
  654.   # Gibt die Bitmap mit einem bestimmten Faktor verkleinert / gestreckt zurĂźck.
  655.   # -- factor_x: Faktor fĂźr horizontale Streckung
  656.   # -- factor_y (factor_x): Faktor fĂźr vertikale Streckung
  657.   #<<<<<<<<<<<<<<<<<<<
  658.   def scale(factor_x, factor_y=factor_x)
  659.     buffer = Bitmap.new(width*factor_x, height*factor_y)
  660.     buffer.stretch_blt(buffer.rect, self, rect)
  661.     return buffer
  662.   end
  663.   #-------------
  664.   #>>>>>>>>>>>>>>>>>>>
  665.   # Gibt die Bitmap auf eine bestimmte Größe gestreckt / verkleinert zurĂźck.
  666.   # -- width: Breite
  667.   # -- height: HĂśhe
  668.   #<<<<<<<<<<<<<<<<<<<
  669.   def scale_to(width, height)
  670.     factor_x = width.to_f / self.width
  671.     factor_y = height.to_f / self.height
  672.     return scale(factor_x, factor_y)
  673.   end
  674.   #-------------
  675.   #>>>>>>>>>>>>>>>>>>>
  676.   # Gibt einen Teil der Bitmap auf die volle Größe gestreckt zurĂźck.
  677.   # -- x, y, width, height: Ausschnitt der Bitmap
  678.   #<<<<<<<<<<<<<<<<<<<
  679.   def zoom_area(x, y, width, height)
  680.     return area(x, y, width, height).scale_to(self.width, self.height)
  681.   end
  682.   #-------------
  683.   #>>>>>>>>>>>>>>>>>>>
  684.   # Ändert die Bitmap zu einem Ausschnitt, der auf die volle Größe
  685.   # gestreckt wird.
  686.   # -- x, y, width, height: Ausschnitt der Bitmap
  687.   #<<<<<<<<<<<<<<<<<<<
  688.   def zoom_area!(x, y, width, height)
  689.     buffer = zoom_area(x, y, width, height)
  690.     clear
  691.     blt(0, 0, buffer, Rect.new(0, 0, self.width, self.height))
  692.   end
  693.   #-------------
  694.   #>>>>>>>>>>>>>>>>>>>
  695.   # Ändert die Opacity der Bitmap.
  696.   # -- opacity: Wert zwischen 0 und 255
  697.   #<<<<<<<<<<<<<<<<<<<
  698.   def change_opacity(opacity)
  699.     buffer = Bitmap.new(width, height)
  700.     buffer.blt(0, 0, self, Rect.new(0, 0, width, height), opacity)
  701.     clear
  702.     blt(0, 0, buffer, Rect.new(0, 0, self.width, self.height))
  703.   end
  704.   #-------------
  705.   #>>>>>>>>>>>>>>>>>>>
  706.   # Zeichnet ein mit einem FarbĂźbergang gefĂźlltes Rechteck.
  707.   # -- x, y, width, height: Rechteck
  708.   # -- color1: erste Farbe (links)
  709.   # -- color2: zweite Farbe (rechts)
  710.   #<<<<<<<<<<<<<<<<<<<
  711.   def fill_rect_horizontal_gradient(x, y, width, height, color1, color2)
  712.     r1 = color1.red
  713.     g1 = color1.green
  714.     b1 = color1.blue
  715.     a1 = color1.alpha
  716.     r2 = color2.red
  717.     g2 = color2.green
  718.     b2 = color2.blue
  719.     a2 = color2.alpha
  720.     for i in x..(x+width)
  721.       k = i / (x+width).to_f
  722.       red = k*(r2-r1)+r1
  723.       green = k*(g2-g1)+g1
  724.       blue = k*(b2-b1)+b1
  725.       alpha = k*(a2-a1)+a1
  726.       color = Color.new(red, green, blue, alpha)
  727.       fill_rect(i, y, 1, height, color)
  728.     end
  729.   end
  730.   #---------------
  731.   #>>>>>>>>>>>>>>>>>>>
  732.   # FĂźllt ein Rechteck, gefĂźllt mit einem vertikalen FarbĂźbergang von
  733.   # color1 zu color2.
  734.   # -- x, y, width, height: Rechteck
  735.   # -- color1: erste Farbe (oben)
  736.   # -- color2: zweite Farbe (unten)
  737.   #<<<<<<<<<<<<<<<<<<<
  738.   def fill_rect_vertical_gradient(x, y, width, height, color1, color2)
  739.     r1 = color1.red
  740.     g1 = color1.green
  741.     b1 = color1.blue
  742.     a1 = color1.alpha
  743.     r2 = color2.red
  744.     g2 = color2.green
  745.     b2 = color2.blue
  746.     a2 = color2.alpha
  747.     for i in y..height
  748.       k = i / (y+height).to_f
  749.       red = k*(r2-r1)+r1
  750.       green = k*(g2-g1)+g1
  751.       blue = k*(b2-b1)+b1
  752.       alpha = k*(a2-a1)+a1
  753.       color = Color.new(red, green, blue, alpha)
  754.       fill_rect(x, i, width, 1, color)
  755.     end
  756.   end
  757.   #-----------------
  758.   #>>>>>>>>>>>>>>>>>
  759.   # Gibt die Bitmap mit vertauschten RGB-Farbwerten zurĂźck.
  760.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  761.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  762.   #<<<<<<<<<<<<<<<<<
  763.   def swap_colors(order)
  764.     buffer = Bitmap.new(width, height)
  765.     for x in 0..width
  766.       for y in 0..height
  767.         color = get_pixel(x, y).swap(order)
  768.         buffer.set_pixel(x, y, color)
  769.       end
  770.     end
  771.     return buffer
  772.   end
  773.   #-----------------
  774.   #>>>>>>>>>>>>>>>>>
  775.   # Vertauscht die RGB-Farbwerte der Bitmap.
  776.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  777.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  778.   #<<<<<<<<<<<<<<<<<
  779.   def swap_colors!(order)
  780.     for x in 0..width
  781.       for y in 0..height
  782.         color = get_pixel(x, y).swap(order)
  783.         set_pixel(x, y, color)
  784.       end
  785.     end
  786.   end
  787.   #-----------------
  788.   #>>>>>>>>>>>>>>>>>
  789.   # Gibt die Bitmap mit ersetzten Farben zurĂźck.
  790.   # -- red, green, blue, alpha: zu ersetzende Farbe, die Parameter kĂśnnen sein:
  791.   #     - ein genauer Wert, z.B. 172
  792.   #     - ein Wertebereich, z.B. 100..200
  793.   #     - -1 (Farbwert ist egal)
  794.   # -- red2, green2, blue2, alpha2: neue Farbe, die Parameter kĂśnnen sein:
  795.   #     - ein genauer Wert, z.B. 215
  796.   #     - -1 (Farbwert wird nicht geändert)
  797.   #<<<<<<<<<<<<<<<<<
  798.   def replace_colors(red, green, blue, alpha, red2, green2, blue2, alpha2)
  799.     buffer = Bitmap.new(width, height)
  800.     for x in 0..width
  801.       for y in 0..height
  802.         color = get_pixel(x, y)
  803.         if ((red.is_a?(Range) and red.include?(color.red)) or
  804.               color.red == red or
  805.                red == -1) and
  806.             ((green.is_a?(Range) and green.include?(color.green)) or
  807.               color.green == green or
  808.               green == -1) and
  809.             ((blue.is_a?(Range) and blue.include?(color.blue)) or
  810.               color.blue == blue or
  811.               blue == -1)  and
  812.             ((alpha.is_a?(Range) and alpha.include?(color.alpha)) or
  813.               color.alpha == alpha or
  814.               alpha == -1)
  815.           new_red = red2 == -1 ? color.red : red2
  816.           new_green = green2 == -1 ? color.green : green2
  817.           new_blue = blue2 == -1 ? color.blue : blue2
  818.           new_alpha = alpha2 == -1 ? color.alpha : alpha2
  819.           new_color = Color.new(new_red, new_green, new_blue, new_alpha)
  820.         else
  821.           new_color = get_pixel(x, y)
  822.         end
  823.         buffer.set_pixel(x, y, new_color)
  824.       end
  825.     end
  826.     return buffer
  827.   end
  828.   #-----------------
  829.   #>>>>>>>>>>>>>>>>>
  830.   # Ersetzt Farben.
  831.   # -- red, green, blue, alpha: zu ersetzende Farbe, die Parameter kĂśnnen sein:
  832.   #     - ein genauer Wert, z.B. 172
  833.   #     - ein Wertebereich, z.B. 100..200
  834.   #     - -1 (Farbwert ist egal)
  835.   # -- red2, green2, blue2, alpha2: neue Farbe, die Parameter kĂśnnen sein:
  836.   #     - ein genauer Wert, z.B. 215
  837.   #     - -1 (Farbwert wird nicht geändert)
  838.   #<<<<<<<<<<<<<<<<<
  839.   def replace_colors!(red, green, blue, alpha, red2, green2, blue2, alpha2)
  840.     buffer = replace_colors(red, green, blue, alpha, red2, green2, blue2, alpha2)
  841.     clear
  842.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  843.   end
  844.   #-----------------
  845.   #>>>>>>>>>>>>>>>>>
  846.   # Gibt einen Ausschnitt der Bitmap zurĂźck.
  847.   # -- x, y, width, height: Ausschnitt
  848.   #<<<<<<<<<<<<<<<<<
  849.   def area(x, y, width, height)
  850.     buffer = Bitmap.new(width, height)
  851.     src_rect = Rect.new(x, y, width, height)
  852.     buffer.blt(0, 0, self, src_rect)
  853.     return buffer
  854.   end
  855.   #-----------------
  856.   #>>>>>>>>>>>>>>>>>
  857.   # Gibt die durchschnittliche Farbe in einem Ausschnitt der Bitmap zurĂźck.
  858.   # -- x, y, width, height: Ausschnitt
  859.   # Die Methode ist ein wenig unperformant, sollte also nicht zu oft
  860.   # hintereinander aufgerufen werden.
  861.   #<<<<<<<<<<<<<<<<<
  862.   def average_color(x, y, width, height)
  863.     width = [self.width, x+width].min
  864.     height = [self.height, y+height].min
  865.     red = green = blue = alpha = 0
  866.     count = 0
  867.     for ix in x..width
  868.       for iy in y..height
  869.         px = get_pixel(ix, iy)
  870.         red += px.red
  871.         green += px.green
  872.         blue += px.blue
  873.         alpha += px.alpha
  874.         count += 1
  875.       end
  876.     end
  877.     red /= count
  878.     green /= count
  879.     blue /= count
  880.     alpha /= count
  881.     return Color.new(red, green, blue, alpha)
  882.   end
  883. end
  884. #====
  885. class Color
  886.   #>>>>>>>>>>>>>>>>>>>>>
  887.   # Gibt die Farbe als Integer zurĂźck. Das erste Byte steht fĂźr den
  888.   # Alpha-Wert, das zweite fĂźr den Rot-Wert etc.
  889.   #<<<<<<<<<<<<<<<<<<<<<
  890.   def int
  891.     return ((alpha.to_i & 0xFF) << 24) |
  892.               ((red.to_i & 0xFF) << 16) |
  893.               ((green.to_i & 0xFF) << 8) |
  894.               ((blue.to_i & 0xFF) << 0)
  895.   end
  896.   #----------
  897.   #>>>>>>>>>>>>>>>>>>>>>
  898.   # Gibt eine etwas hellere Farbe zurĂźck.
  899.   # -- factor: der Faktor, mit dem die Farbe errechnet wird, muss
  900.   #     zwischen 0.0 und 1.0 liegen
  901.   # Die Methoden brighter und darker sind nicht umkehrbar!
  902.   #<<<<<<<<<<<<<<<<<<<<<
  903.   def brighter(factor=0.7)
  904.     factor = 1-[[0, factor].max, 1].min
  905.     new_red = factor*(255-red) + red
  906.     new_green = factor*(255-green) + green
  907.     new_blue = factor*(255-blue) + blue
  908.     return Color.new(new_red, new_green, new_blue, alpha)
  909.   end
  910.   #--------
  911.   #>>>>>>>>>>>>>>>>>>>>>
  912.   # Gibt eine etwas dunklere Farbe zurĂźck.
  913.   # -- factor: der Faktor, mit dem die Farbe errechnet wird, muss
  914.   #     zwischen 0.0 und 1.0 liegen
  915.   # Die Methoden brighter und darker sind nicht umkehrbar!
  916.   #<<<<<<<<<<<<<<<<<<<<<
  917.   def darker(factor=0.7)
  918.     factor = [[0, factor].max, 1].min
  919.     new_red = red * factor
  920.     new_green = green * factor
  921.     new_blue = blue * factor
  922.     return Color.new(new_red, new_green, new_blue, alpha)
  923.   end
  924.   #-----------
  925.   #>>>>>>>>>>>>>>>>>>>
  926.   # Gibt die Komplementärfarbe zurĂźck, d.h. die RGB-Werte werden
  927.   # umgekehrt.
  928.   #<<<<<<<<<<<<<<<<<<<
  929.   def negative
  930.     #return Color.new(255-red, 255-green, 255-blue, alpha)
  931.     #return int ^ 0xFFFFFF
  932.     return Color.new(red ^ 0xFF, green ^ 0xFF, blue ^ 0xFF, alpha)
  933.   end
  934.   #-----------
  935.   #>>>>>>>>>>>>>>>>>>>
  936.   # Gibt die Farbe als Graustufe zurĂźck, d.h. die RGB-Werte sind gleich.
  937.   #<<<<<<<<<<<<<<<<<<<
  938.   def grayscale
  939.     g = average
  940.     return Color.new(g, g, g, alpha)
  941.   end
  942.   #-----------
  943.   #>>>>>>>>>>>>>>>>>>>
  944.   # Gibt den Durchschnitt der RGB-Werte zurĂźck.
  945.   #<<<<<<<<<<<<<<<<<<<
  946.   def average
  947.     return Math.average(red, green, blue)
  948.   end
  949.   #-----------
  950.   #>>>>>>>>>>>>>>>>>>>
  951.   # Gibt die Farbe mit vertauschten Werten zurĂźck.
  952.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  953.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  954.   #<<<<<<<<<<<<<<<<<<<
  955.   def swap(order)
  956.     order.downcase!
  957.     o = ["rbg", "bgr", "brg", "grb", "gbr"]
  958.     return self if not o.include?(order)
  959.     case o.index(order)
  960.     when 0
  961.       return Color.new(red, blue, green, alpha)
  962.     when 1
  963.       return Color.new(blue, green, red, alpha)
  964.     when 2
  965.       return Color.new(blue, red, green, alpha)
  966.     when 3
  967.       return Color.new(green, red, blue, alpha)
  968.     when 4
  969.       return Color.new(green, blue, red, alpha)
  970.     end
  971.   end
  972.   #-----------
  973.   #>>>>>>>>>>>>>>>>>>>
  974.   # Gibt die Farbe in der Hexadezimalschreibweise (als String) zurĂźck.
  975.   #<<<<<<<<<<<<<<<<<<<
  976.   def encode
  977.     format = "%02x"
  978.     return (format % red) + (format % green) + (format % blue) + (format % alpha)
  979.   end
  980.   #-----------
  981.   #>>>>>>>>>>>>>>>>>>>
  982.   # Wertet einen String in der Hexadezimalschreibweise (z.B. "0082d6")
  983.   # aus und gibt die Farbe zurĂźck.
  984.   #<<<<<<<<<<<<<<<<<<<
  985.   def Color.decode(hex)
  986.     hex.downcase!
  987.     red = hex[0..1].hex
  988.     green = hex[2..3].hex
  989.     blue = hex[4..5].hex
  990.     alpha = hex.length == 8 ? hex[6..7].hex : 255
  991.     return Color.new(red, green, blue, alpha)
  992.   end
  993.   #-----------
  994.   #>>>>>>>>>>>>>>>>>>>
  995.   # einige Farbkonstanten, sehr nĂźtzlich:
  996.   #<<<<<<<<<<<<<<<<<<<
  997.   def Color.white(alpha=255)
  998.     return Color.new(255, 255, 255, alpha)
  999.   end
  1000.   #-----------
  1001.   def Color.black(alpha=255)
  1002.     return Color.new(0, 0, 0, alpha)
  1003.   end
  1004.   #----------
  1005.   def Color.red(alpha=255)
  1006.     return Color.new(255, 0, 0, alpha)
  1007.   end
  1008.   #----------
  1009.   def Color.green(alpha=255)
  1010.     return Color.new(0, 255, 0, alpha)
  1011.   end
  1012.   #---------
  1013.   def Color.blue(alpha=255)
  1014.     return Color.new(0, 0, 255, alpha)
  1015.   end
  1016.   #----------
  1017.   def Color.yellow(alpha=255)
  1018.     return Color.new(255, 255, 0, alpha)
  1019.   end
  1020.   #----------
  1021.   def Color.cyan(alpha=255)
  1022.     return Color.new(0, 255, 255, alpha)
  1023.   end
  1024.   #----------
  1025.   def Color.magenta(alpha=255)
  1026.     return Color.new(255, 255, 0, alpha)
  1027.   end
  1028.   #----------
  1029.   def Color.light_gray(alpha=255)
  1030.     return Color.new(192, 192, 192, alpha)
  1031.   end
  1032.   #-----------
  1033.   def Color.gray(alpha=255)
  1034.     return Color.new(128, 128, 128, alpha)
  1035.   end
  1036.   #-----------
  1037.   def Color.dark_gray(alpha=255)
  1038.     return Color.new(64, 64, 64, alpha)
  1039.   end
  1040.   #-----------
  1041.   def Color.pink(alpha=255)
  1042.     return Color.new(255, 175, 175, alpha)
  1043.   end
  1044.   #-----------
  1045.   def Color.orange(alpha=255)
  1046.     return Color.new(255, 200, 0, alpha)
  1047.   end
  1048. end
  1049. #==========
  1050. class Rect
  1051.   #>>>>>>>>>>>>>>>>>>>>>
  1052.   # Gibt true zurĂźck, wenn der Punkt (x, y) innerhalb des Rechteckes liegt.
  1053.   #<<<<<<<<<<<<<<<<<<<<<
  1054.   def inside?(x, y)
  1055.     return ((x >= self.x) and (x < self.x+width) and
  1056.         (y >= self.y) and (y < self.y+height))
  1057.   end
  1058. end
  1059. #==========
  1060. class Window_Base
  1061.   #>>>>>>>>>>>>>>>>>>>>>
  1062.   # Zeichnet die Battlergrafik.
  1063.   # -- actor: der Held, dessen Grafik gezeichnet werden soll
  1064.   #<<<<<<<<<<<<<<<<<<<<<
  1065.   def draw_actor_battler(actor, x, y)
  1066.     bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
  1067.     self.contents.blt(x, y, bitmap, Rect.new(0, 0, bitmap.width, bitmap.height))
  1068.   end
  1069. end
  1070. #==========
  1071. module Math
  1072.   #>>>>>>>>>>>>>>>>>>>>>
  1073.   # Gibt den Absolutwert (Betrag) einer Zahl zurĂźck.
  1074.   #<<<<<<<<<<<<<<<<<<<<<
  1075.   def self.abs(num)
  1076.     return num<0 ? -num : num
  1077.   end
  1078.   #----------
  1079.   #>>>>>>>>>>>>>>>>>>>>>
  1080.   # Errechnet den Durchschnitt der Ăźbergebenen Zahlen.
  1081.   #<<<<<<<<<<<<<<<<<<<<<
  1082.   def self.average(*nums)
  1083.     sum = 0
  1084.     for i in nums
  1085.       sum += i
  1086.     end
  1087.     return sum.to_f / nums.size
  1088.   end
  1089. end
  1090. #//////////////////////////////////////////////////////////
  1091. # Verbesserungsvorschläge, Bugreports etc. an [email protected]
  1092. #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!