minigl 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 683014cfbecd482d631925ec45ee1326021e024a
-  data.tar.gz: ee579a15c9f2eaf33e5ebffd6349553299b5fdbd
+  metadata.gz: fda5e695d12ea20cd3a5a85554b55f8fd1bb29e7
+  data.tar.gz: f864987fbf4fe1a042a4a48191ac2b12625e4602
 SHA512:
-  metadata.gz: d3751ccd5c52458864578752a7f10a71db732e5ec0514a258e3cef6feece6e30df6d1563525a00ee4f2e4c1b017045eab0a9fb6818a48997c62a03f0b7ed914c
-  data.tar.gz: fda44bd25b989ffe54b2208f6883662c2baeeb8384d7453ecb6fa0edf8286d36020c81aa42bfd38d3998458617312b398fbe867147334041f0142026d3fcd162
+  metadata.gz: c8850221370b6f6a77412059b6743a341adefbc5f91bbcffff09b24ce351eaa1782c3f1f440d2aba17cf1ed326710ea906a1cac6cac5ed81da79ec5cef188348
+  data.tar.gz: 2629a2fe8113011548014bfb651afb2b408e921d188a6ab2abd03c352a867000cf39f4f723a52d8cc24cbcf5d98c44c186b51e99b295bc67b19850d05bbfba6c

data/README.md

@@ -32,9 +32,29 @@ examples provided with the gem.
   * An auxiliary, tutorial-like documentation is under construction
 [here](https://github.com/victords/minigl/wiki/How-To).
 
-**Version 2.0.2**
-
-  * Small adjustment in `GameWindow#clear`, changing the format of the color
-parameter from AARRGGBB to RRGGBB (as the alpha would have no effect).
-  * Addition of the `flip` parameter to the `draw` method of `Sprite` and
-`GameObject`.
+## Version 2.0.3
+
+  * Flexibilization of various methods and constructors with named parameters.
+Please note I haven't used the "official" Ruby syntax for named parameters, but
+the "first parameter as hash" technique (in order to keep the positional call
+available), so you will need to be careful to include all the mandatory
+parameters in your hash, or you could face some strange errors (you can find out
+the mandatory parameters in the documentation). Here is the list of flexibilized
+methods:
+    * `GameWindow::new`
+    * `Sprite#draw`
+    * `GameObject#draw`
+    * `TextHelper#write_line`
+    * `Button::new`
+    * `ToggleButton::new`
+    * `TextField::new`
+    * `ProgressBar::new`
+    * `DropDownList::new`
+  * Flexibilization of `Mouse::over?` with the possibility of passing a single
+parameter (a `Rectangle` object) instead of four coordinates.
+  * Passing of the `set_animation` method from `GameObject` to `Sprite`, so the
+sprites also support it (`GameObject` still supports because it inherits from
+`Sprite`).
+  * Change of the parameter order in `TextHelper#write_line`, so that `alpha`
+comes right after `color`, and not after all the `effect_...` parameters. **This
+could generate incompatibility.**

data/lib/minigl/forms.rb

@@ -29,9 +29,7 @@ module MiniGL
     # for each specific component class.
     attr_accessor :params
 
-    # This constructor is for internal use of the subclasses only. Do not
-    # instantiate objects of this class.
-    def initialize(x, y, font, text, text_color, disabled_text_color)
+    def initialize(x, y, font, text, text_color, disabled_text_color) # :nodoc:
       @x = x
       @y = y
       @font = font
@@ -93,8 +91,32 @@ module MiniGL
     #          parameters.
     # [action] The block of code executed when the button is clicked (or by
     #          calling the +click+ method).
-    def initialize(x, y, font, text, img, text_color = 0, disabled_text_color = 0, over_text_color = 0, down_text_color = 0,
+    #
+    # *Obs.:* This method accepts named parameters, but +x+ and +y+ are
+    # mandatory (also, +img+ is mandatory when +width+ and +height+ are not
+    # provided, and vice-versa).
+    def initialize(x, y = nil, font = nil, text = nil, img = nil,
+                   text_color = 0, disabled_text_color = 0, over_text_color = 0, down_text_color = 0,
                    center_x = true, center_y = true, margin_x = 0, margin_y = 0, width = nil, height = nil, params = nil, &action)
+      if x.is_a? Hash
+        y = x[:y]
+        font = x[:font]
+        text = x[:text]
+        img = x[:img]
+        text_color = x.fetch(:text_color, 0)
+        disabled_text_color = x.fetch(:disabled_text_color, 0)
+        over_text_color = x.fetch(:over_text_color, 0)
+        down_text_color = x.fetch(:down_text_color, 0)
+        center_x = x.fetch(:center_x, true)
+        center_y = x.fetch(:center_y, true)
+        margin_x = x.fetch(:margin_x, 0)
+        margin_y = x.fetch(:margin_y, 0)
+        width = x.fetch(:width, nil)
+        height = x.fetch(:height, nil)
+        params = x.fetch(:params, nil)
+        x = x[:x]
+      end
+
       super x, y, font, text, text_color, disabled_text_color
       @over_text_color = over_text_color
       @down_text_color = down_text_color
@@ -249,8 +271,33 @@ module MiniGL
     #     puts "button was checked" if checked
     #     # do something with params
     #   }
-    def initialize(x, y, font, text, img, checked = false, text_color = 0, disabled_text_color = 0, over_text_color = 0, down_text_color = 0,
+    #
+    # *Obs.:* This method accepts named parameters, but +x+ and +y+ are
+    # mandatory (also, +img+ is mandatory when +width+ and +height+ are not
+    # provided, and vice-versa).
+    def initialize(x, y = nil, font = nil, text = nil, img = nil, checked = false,
+                   text_color = 0, disabled_text_color = 0, over_text_color = 0, down_text_color = 0,
                    center_x = true, center_y = true, margin_x = 0, margin_y = 0, width = nil, height = nil, params = nil, &action)
+      if x.is_a? Hash
+        y = x[:y]
+        font = x[:font]
+        text = x[:text]
+        img = x[:img]
+        checked = x.fetch(:checked, false)
+        text_color = x.fetch(:text_color, 0)
+        disabled_text_color = x.fetch(:disabled_text_color, 0)
+        over_text_color = x.fetch(:over_text_color, 0)
+        down_text_color = x.fetch(:down_text_color, 0)
+        center_x = x.fetch(:center_x, true)
+        center_y = x.fetch(:center_y, true)
+        margin_x = x.fetch(:margin_x, 0)
+        margin_y = x.fetch(:margin_y, 0)
+        width = x.fetch(:width, nil)
+        height = x.fetch(:height, nil)
+        params = x.fetch(:params, nil)
+        x = x[:x]
+      end
+
       super x, y, font, text, nil, text_color, disabled_text_color, over_text_color, down_text_color,
             center_x, center_y, margin_x, margin_y, width, height, params, &action
       @img =
@@ -359,8 +406,32 @@ module MiniGL
     #                   field is changed, either by user input or by calling
     #                   +text=+. The new text is passed as a first parameter
     #                   to this block, followed by +params+. Can be +nil+.
-    def initialize(x, y, font, img, cursor_img = nil, disabled_img = nil, margin_x = 0, margin_y = 0, max_length = 100, active = false, text = '',
-                   allowed_chars = nil, text_color = 0, disabled_text_color = 0, selection_color = 0, locale = 'en-us', params = nil, &on_text_changed)
+    #
+    # *Obs.:* This method accepts named parameters, but +x+, +y+, +font+ and
+    # +img+ are mandatory.
+    def initialize(x, y = nil, font = nil, img = nil, cursor_img = nil, disabled_img = nil, margin_x = 0, margin_y = 0,
+                   max_length = 100, active = false, text = '', allowed_chars = nil,
+                   text_color = 0, disabled_text_color = 0, selection_color = 0, locale = 'en-us', params = nil, &on_text_changed)
+      if x.is_a? Hash
+        y = x[:y]
+        font = x[:font]
+        img = x[:img]
+        cursor_img = x.fetch(:cursor_img, nil)
+        disabled_img = x.fetch(:disabled_img, nil)
+        margin_x = x.fetch(:margin_x, 0)
+        margin_y = x.fetch(:margin_y, 0)
+        max_length = x.fetch(:max_length, 100)
+        active = x.fetch(:active, false)
+        text = x.fetch(:text, '')
+        allowed_chars = x.fetch(:allowed_chars, nil)
+        text_color = x.fetch(:text_color, 0)
+        disabled_text_color = x.fetch(:disabled_text_color, 0)
+        selection_color = x.fetch(:selection_color, 0)
+        locale = x.fetch(:locale, 'en-us')
+        params = x.fetch(:params, nil)
+        x = x[:x]
+      end
+
       super x, y, font, text, text_color, disabled_text_color
       @img = Res.img img
       @w = @img.width
@@ -598,17 +669,17 @@ module MiniGL
     def locale=(value)
       @locale = value.downcase
       @chars =
-          case @locale
-            when 'en-us' then "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ`-=[]\\;',./~_+{}|:\"<>?!@#$%^&*()+-*/"
-            when 'pt-br' then "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ'-=/[]ç~,.;\"_+?{}Ç^<>:!@#$%¨&*()+-*/"
-            else              '###################################################################################################'
-          end
+        case @locale
+          when 'en-us' then "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ`-=[]\\;',./~_+{}|:\"<>?!@#$%^&*()+-*/"
+          when 'pt-br' then "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ'-=/[]ç~,.;\"_+?{}Ç^<>:!@#$%¨&*()+-*/"
+          else              '###################################################################################################'
+        end
       @allowed_chars =
-          if @user_allowed_chars
-            @user_allowed_chars
-          else
-            @chars
-          end
+        if @user_allowed_chars
+          @user_allowed_chars
+        else
+          @chars
+        end
     end
 
     # Returns the currently selected text.
@@ -799,8 +870,28 @@ module MiniGL
     # [text_color] Color of the text.
     # [format] Format to display the value. Specify '%' for a percentage and
     #          anything else for absolute values (current/maximum).
-    def initialize(x, y, w, h, bg, fg, max_value = 100, value = 100, fg_margin_x = 0, fg_margin_y = 0, #fg_left = nil, fg_right = nil,
+    #
+    # *Obs.:* This method accepts named parameters, but +x+, +y+, +w+, +h+, +bg+
+    # and +fg+ are mandatory.
+    def initialize(x, y = nil, w = nil, h = nil, bg = nil, fg = nil,
+                   max_value = 100, value = 100, fg_margin_x = 0, fg_margin_y = 0, #fg_left = nil, fg_right = nil,
                    font = nil, text_color = 0, format = nil)
+      if x.is_a? Hash
+        y = x[:y]
+        w = x[:w]
+        h = x[:h]
+        bg = x[:bg]
+        fg = x[:fg]
+        max_value = x.fetch(:max_value, 100)
+        value = x.fetch(:value, 100)
+        fg_margin_x = x.fetch(:fg_margin_x, 0)
+        fg_margin_y = x.fetch(:fg_margin_y, 0)
+        font = x.fetch(:font, nil)
+        text_color = x.fetch(:text_color, 0)
+        format = x.fetch(:format, nil)
+        x = x[:x]
+      end
+
       super x, y, font, '', text_color, text_color
       @w = w
       @h = h
@@ -950,8 +1041,30 @@ module MiniGL
     # [disabled_text_color] Analogous to +text_color+.
     # [over_text_color] Same as above.
     # [down_text_color] Same as above.
-    def initialize(x, y, font, img, opt_img, options, option = 0, text_margin = 0, width = nil, height = nil,
+    #
+    # *Obs.:* This method accepts named parameters, but +x+, +y+, +font+ and
+    # +options+ are mandatory (also, +img+ and +opt_img+ are mandatory when
+    # +width+ and +height+ are not provided, and vice-versa).
+    def initialize(x, y = nil, font = nil, img = nil, opt_img = nil, options = nil,
+                   option = 0, text_margin = 0, width = nil, height = nil,
                    text_color = 0, disabled_text_color = 0, over_text_color = 0, down_text_color = 0)
+      if x.is_a? Hash
+        y = x[:y]
+        font = x[:font]
+        img = x[:img]
+        opt_img = x[:opt_img]
+        options = x[:options]
+        option = x.fetch(:option, 0)
+        text_margin = x.fetch(:text_margin, 0)
+        width = x.fetch(:width, nil)
+        height = x.fetch(:height, nil)
+        text_color = x.fetch(:text_color, 0)
+        disabled_text_color = x.fetch(:disabled_text_color, 0)
+        over_text_color = x.fetch(:over_text_color, 0)
+        down_text_color = x.fetch(:down_text_color, 0)
+        x = x[:x]
+      end
+
       super x, y, font, options[option], text_color, disabled_text_color
       @img = img
       @opt_img = opt_img

data/lib/minigl/game_object.rb

@@ -66,6 +66,17 @@ module MiniGL
       end
     end
 
+    # Resets the animation timer and immediately changes the image index to
+    # the specified value.
+    #
+    # Parameters:
+    # [index] The image index to be set.
+    def set_animation(index)
+      @anim_counter = 0
+      @img_index = index
+      @index_index = 0
+    end
+
     # Draws the sprite in the screen
     #
     # Parameters:
@@ -87,7 +98,20 @@ module MiniGL
     #        to draw it vertically flipped.
     # [z_index] The z-order to draw the object. Objects with larger z-orders
     #           will be drawn on top of the ones with smaller z-orders.
+    #
+    # *Obs.:* This method accepts named parameters.
     def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0)
+      if map.is_a? Hash
+        scale_x = map.fetch(:scale_x, 1)
+        scale_y = map.fetch(:scale_y, 1)
+        alpha = map.fetch(:alpha, 0xff)
+        color = map.fetch(:color, 0xffffff)
+        angle = map.fetch(:angle, nil)
+        flip = map.fetch(:flip, nil)
+        z_index = map.fetch(:z_index, 0)
+        map = map.fetch(:map, nil)
+      end
+
       color = (alpha << 24) | color
       if angle
         @img[@img_index].draw_rot @x.round - (map ? map.cam.x : 0) + (flip == :horiz ? scale_x * @img[0].width : 0),
@@ -154,17 +178,6 @@ module MiniGL
       @stored_forces = Vector.new 0, 0
     end
 
-    # Resets the animation timer and immediately changes the image index to
-    # the specified value.
-    #
-    # Parameters:
-    # [index] The image index to be set.
-    def set_animation(index)
-      @anim_counter = 0
-      @img_index = index
-      @index_index = 0
-    end
-
     # Draws the game object in the screen.
     #
     # Parameters:
@@ -186,7 +199,20 @@ module MiniGL
     #        to draw it vertically flipped.
     # [z_index] The z-order to draw the object. Objects with larger z-orders
     #           will be drawn on top of the ones with smaller z-orders.
+    #
+    # *Obs.:* This method accepts named parameters.
     def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0)
+      if map.is_a? Hash
+        scale_x = map.fetch(:scale_x, 1)
+        scale_y = map.fetch(:scale_y, 1)
+        alpha = map.fetch(:alpha, 0xff)
+        color = map.fetch(:color, 0xffffff)
+        angle = map.fetch(:angle, nil)
+        flip = map.fetch(:flip, nil)
+        z_index = map.fetch(:z_index, 0)
+        map = map.fetch(:map, nil)
+      end
+
       color = (alpha << 24) | color
       if angle
         @img[@img_index].draw_rot @x.round + (flip == :horiz ? -1 : 1) * @img_gap.x - (map ? map.cam.x : 0) + (flip == :horiz ? scale_x * @w : 0),
@@ -247,8 +273,25 @@ module MiniGL
     #             '.wav'.
     # [sound_volume] The volume (from 0 to 1) to play the sound, if any. Default
     #                is 1.
-    def initialize(x, y, img, sprite_cols = nil, sprite_rows = nil, interval = 10, indices = nil, lifetime = nil,
+    #
+    # *Obs.:* This method accepts named parameters, but +x+, +y+ and +img+ are
+    # mandatory.
+    def initialize(x, y = nil, img = nil, sprite_cols = nil, sprite_rows = nil, interval = 10, indices = nil, lifetime = nil,
                    sound = nil, sound_ext = '.wav', sound_volume = 1)
+      if x.is_a? Hash
+        y = x[:y]
+        img = x[:img]
+        sprite_cols = x.fetch(:sprite_cols, nil)
+        sprite_rows = x.fetch(:sprite_rows, nil)
+        interval = x.fetch(:interval, 10)
+        indices = x.fetch(:indices, nil)
+        lifetime = x.fetch(:lifetime, nil)
+        sound = x.fetch(:sound, nil)
+        sound_ext = x.fetch(:sound_ext, '.wav')
+        sound_volume = x.fetch(:sound_volume, 1)
+        x = x[:x]
+      end
+
       super x, y, img, sprite_cols, sprite_rows
       @timer = 0
       if indices

data/lib/minigl/global.rb

@@ -193,10 +193,27 @@ module MiniGL
     # [double_click_delay] The maximum interval, in frames, between two
     #                      clicks, to trigger the "double click" event
     #                      (checked with <code>Mouse.double_click?</code>).
-    def initialize(scr_w, scr_h, fullscreen = true,
+    #
+    # *Obs.:* This method accepts named parameters, but +scr_w+ and +scr_h+ are
+    # mandatory.
+    def initialize(scr_w, scr_h = nil, fullscreen = true,
                    gravity = Vector.new(0, 1), min_speed = Vector.new(0.01, 0.01),
-                   ramp_contact_threshold = 4, ramp_slip_threshold = 1.2, ramp_slip_force = 0.1,
+                   ramp_contact_threshold = 4, ramp_slip_threshold = 1.1, ramp_slip_force = 0.1,
                    kb_held_delay = 40, kb_held_interval = 5, double_click_delay = 8)
+      if scr_w.is_a? Hash
+        scr_h = scr_w[:scr_h]
+        fullscreen = scr_w.fetch(:fullscreen, true)
+        gravity = scr_w.fetch(:gravity, Vector.new(0, 1))
+        min_speed = scr_w.fetch(:min_speed, Vector.new(0.01, 0.01))
+        ramp_contact_threshold = scr_w.fetch(:ramp_contact_threshold, 4)
+        ramp_slip_threshold = scr_w.fetch(:ramp_slip_threshold, 1.1)
+        ramp_slip_force = scr_w.fetch(:ramp_slip_force, 0.1)
+        kb_held_delay = scr_w.fetch(:kb_held_delay, 40)
+        kb_held_interval = scr_w.fetch(:kb_held_interval, 5)
+        double_click_delay = scr_w.fetch(:double_click_delay, 8)
+        scr_w = scr_w[:scr_w]
+      end
+
       super scr_w, scr_h, fullscreen
       G.window = self
       G.gravity = gravity
@@ -435,8 +452,16 @@ module MiniGL
       # [y] The y-coordinate of the top left corner of the area.
       # [w] The width of the area.
       # [h] The height of the area.
-      def over?(x, y, w, h)
-        @x >= x and @x < x + w and @y >= y and @y < y + h
+      #
+      # <b>Alternate syntax</b>
+      #
+      # <code>over?(rectangle)</code>
+      #
+      # Parameters:
+      # [rectangle] A rectangle representing the area to be checked.
+      def over?(x, y = nil, w = nil, h = nil)
+        return @x >= x.x && @x < x.x + x.w && @y >= x.y && @y < x.y + x.h if x.is_a? Rectangle
+        @x >= x && @x < x + w && @y >= y && @y < y + h
       end
     end
   end

data/lib/minigl/movement.rb

@@ -30,8 +30,8 @@ module MiniGL
     # [h] The height of the bounding box.
     # [passable] Whether a moving object can pass through this block when
     # coming from below. This is a common feature of platforms in platform
-    # games.
-    def initialize(x, y, w, h, passable)
+    # games. Default is +false+.
+    def initialize(x, y, w, h, passable = false)
       @x = x; @y = y; @w = w; @h = h
       @passable = passable
     end

data/lib/minigl/text.rb

@@ -27,6 +27,8 @@ module MiniGL
     # [mode] The alignment of the text. Valid values are +:left+, +:right+ and
     #        +:center+.
     # [color] The color of the text, in hexadecimal RRGGBB format.
+    # [alpha] The opacity of the text. Valid values vary from 0 (fully
+    #         transparent) to 255 (fully opaque).
     # [effect] Effect to add to the text. It can be either +nil+, for no effect,
     #          +:border+ for bordered text, or +:shadow+ for shadowed text (the
     #          shadow is always placed below and to the right of the text).
@@ -38,13 +40,28 @@ module MiniGL
     #               distance between the text and the shadow.
     # [effect_alpha] Opacity of the effect, if any. For shadows, it is usual to
     #                provide less than 255.
-    # [alpha] The opacity of the text. Valid values vary from 0 (fully
-    #         transparent) to 255 (fully opaque).
     # [z_index] The z-order to draw the object. Objects with larger z-orders
     #           will be drawn on top of the ones with smaller z-orders.
-    def write_line(text, x, y, mode = :left, color = 0,
+    #
+    # *Obs.:* This method accepts named parameters, but +text+, +x+ and +y+ are
+    # mandatory.
+    def write_line(text, x = nil, y = nil, mode = :left, color = 0, alpha = 0xff,
                    effect = nil, effect_color = 0, effect_size = 1, effect_alpha = 0xff,
-                   alpha = 0xff, z_index = 0)
+                   z_index = 0)
+      if text.is_a? Hash
+        x = text[:x]
+        y = text[:y]
+        mode = text.fetch(:mode, :left)
+        color = text.fetch(:color, 0)
+        alpha = text.fetch(:alpha, 0xff)
+        effect = text.fetch(:effect, nil)
+        effect_color = text.fetch(:effect_color, 0)
+        effect_size = text.fetch(:effect_size, 1)
+        effect_alpha = text.fetch(:effect_alpha, 0xff)
+        z_index = text.fetch(:z_index, 0)
+        text = text[:text]
+      end
+
       color = (alpha << 24) | color
       rel =
         case mode

data/test/game.rb

@@ -18,10 +18,10 @@ class MyGame < GameWindow
     @btn = Button.new(10, 560, @font1, 'Test', :btn, 0x008000, 0x808080, 0xffffff, 0xff9980, true, false, 0, 4, 0, 0, 'friends') { |x| puts "hello #{x}" }
     @btn.enabled = false
     @chk =
-      ToggleButton.new(40, 300, @font1, 'Click me', :check, false, 0xffffff, 0x808080, 0x008000, 0xff9980, false, true, 36, 0, 0, 0, 'friends') { |c, x|
+      ToggleButton.new(x: 40, y: 300, font: @font1, text: 'Click me', img: :check, center_x: false, margin_x: 36, params: 'friends') { |c, x|
         puts "hello #{x}, checked: #{c}"
       }
-    @txt = TextField.new(10, 520, @font1, :text, nil, nil, 15, 5, 16, false, '', nil, 0, 0, 0x0000ff, 'PT-BR')
+    @txt = TextField.new(x: 10, y: 520, font: @font1, img: :text, margin_x: 15, margin_y: 5, max_length: 16, locale: 'PT-BR')
     @txt.visible = false
 
     @pb = ProgressBar.new(5, 240, 200, 20, 0xff0000, 0x00ff00, 3456, 70, 0, 0, @font1, 0xff000080)
@@ -83,11 +83,11 @@ class MyGame < GameWindow
     clear 0xabcdef
 
     @obj1.draw nil, 1, 1, 255, 0x33ff33, 30, 1
-    @obj2.draw nil, 0.6, 1.4, 0x99, 0xffffff, nil, :vert
-    @obj3.draw nil, 1, 1, 255, 0xffffff, nil, @flip
-    @writer1.write_line 'Testing effect 1', 400, 260, :center, 0xffffff, :border
-    @writer2.write_line 'Second effect test', 400, 280, :center, 0xffffff, :border, 0xff0000, 2
-    @writer2.write_line 'Text with shadow!!', 400, 340, :center, 0xffff00, :shadow, 0, 2, 0x80
+    @obj2.draw flip: :vert, scale_x: 0.5, scale_y: 1.4
+    @obj3.draw flip: @flip
+    @writer1.write_line text: 'Testing effect 1', x: 400, y: 260, color: 0xffffff, effect: :border
+    @writer2.write_line 'Second effect test', 400, 280, :center, 0xffffff, 255, :border, 0xff0000, 2
+    @writer2.write_line 'Text with shadow!!', 400, 340, :center, 0xffff00, 255, :shadow, 0, 2, 0x80
     @writer1.write_breaking "Testing multiple line text.\nThis should draw text "\
                            'across multiple lines, respecting a limit width. '\
                            'Furthermore, the text must be right-aligned.',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minigl
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Victor David Santos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-08 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu