minigl 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01d773ef32ca54ed13e397c386708830e7731e8e
-  data.tar.gz: 810ff8899be10ec787147090c539ac0d7608f603
+  metadata.gz: d75703110c27893ced02abaa49767ac4137d1b34
+  data.tar.gz: c376306e0d0a7838ebae01863302a418408ce840
 SHA512:
-  metadata.gz: 25128512170f5275e48a8baec43555ab0307f246703cde5eeb55a5d2d4a52ffa9dbc055d5bb7933786eac9c7f00e289c03d8acb982d1aed514482127ebe8f952
-  data.tar.gz: 7e0a5f25b732eaba12c1156e471ea7e1cff6a68774e09be3f3d6e29fbb43903f67420b7aabab0f08640467e34ef24a7a1226d7d05a8f26f17f0c9eaf701db7d1
+  metadata.gz: 221538181848507fc1b079eb9ac34d3c80f4740070641e2a1bfaef34ebe34effce282f36680082c4c6d2051eb9261f48af4b4d25a1428ad913c89cbba1694cad
+  data.tar.gz: e0f31296045813f211981db2c5c46a8b0fa0a044642072749d9396c14810739f5f6667d5a029d437497217bb605f8fb9cdb2e9302297e4e3bdb6293a98ecb2c0

data/README.md

@@ -21,9 +21,8 @@ this [working game example](https://github.com/victords/aventura-do-saber).
   * The [documentation](https://github.com/victords/minigl/wiki) is under
 construction.
 
-**Version 1.2.5**
+**Version 1.2.6**
 
-  * Added support for "invisible" buttons (for associating actions with clicks
-in screen areas).
-  * Exposed `Button`'s `click` method and `TextField`'s `focus` and `unfocus`
-methods.
+  * Added support for character restriction in `TextField`.
+  * Added `set_position` method to `Button` and `TextField`.
+  * Added RDoc documentation.

data/Rakefile

@@ -5,3 +5,7 @@ Rake::TestTask.new do |t|
 	t.test_files = FileList['test/*_tests.rb']
 	t.verbose = true
 end
+
+task :doc do |t|
+	sh "rdoc lib/minigl/*.rb"
+end

data/lib/minigl/forms.rb

@@ -1,7 +1,34 @@
 require_relative 'global'
 
 module AGL
+	# This class represents a button.
 	class Button
+		# Creates a button.
+		# Parameters:
+		# [x] The x-coordinate where the button will be drawn in the screen.
+		# [y] The y-coordinate where the button will be drawn in the screen.
+		# [font] The <code>Gosu::Font</code> object that will be used to draw the
+		#        button text.
+		# [text] The button text. Can be +nil+ or empty.
+		# [img] A spritesheet containing three images in a column, representing,
+		#       from top to bottom, the default state, the hover state (when the
+		#       mouse is over the button) and the pressed state (when the mouse
+		#       button is down and the cursor is over the button). If +nil+, the
+		#       +width+ and +height+ parameters must be provided.
+		# [text_color] Color of the button text, in hexadecimal RRGGBB format.
+		# [center] Whether the button text should be centered in its area (the
+		#          area is defined by the image size, when an image is given, or
+		#          by the +width+ and +height+ parameters, otherwise).
+		# [margin_x] The x offset, from the button x-coordinate, to draw the text.
+		#            This parameter is used only if +center+ is false.
+		# [margin_y] The y offset, from the button y-coordinate, to draw the text.
+		#            This parameter is used only if +center+ is false.
+		# [width] Width of the button clickable area. This parameter is used only
+		#         if +img+ is +nil+.
+		# [height] Height of the button clickable area. This parameter is used
+		#          only if +img+ is +nil+.
+		# [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, center = true, margin_x = 0, margin_y = 0, width = nil, height = nil, &action
 			@x = x
 			@y = y
@@ -30,7 +57,9 @@ module AGL
 			@state = :up
 			@img_index = 0
 		end
-	
+		
+		# Updates the button, checking the mouse movement and buttons to define
+		# the button state.
 		def update
 			mouse_over = Mouse.over? @x, @y, @w, @h
 			mouse_press = Mouse.button_pressed? :left
@@ -69,10 +98,32 @@ module AGL
 			end
 		end
 		
+		# Executes the button click action.
 		def click
 			@action.call
 		end
 		
+		# Sets the position of the button in the screen.
+		# Parameters:
+		# [x] The new x-coordinate for the button.
+		# [y] The new y-coordinate for the button.
+		def set_position x, y
+			d_x = x - @x
+			d_y = y - @y
+			@x = x; @y = y
+			if @center
+				@text_x = x + @w / 2
+				@text_y = y + @h / 2
+			else
+				@text_x += d_x
+				@text_y += d_y
+			end
+		end
+		
+		# Draws the button in the screen.
+		# Parameters:
+		# [alpha] The opacity with which the button will be drawn. Allowed values
+		#         vary between 0 (fully transparent) and 255 (fully opaque).
 		def draw alpha = 0xff
 			color = (alpha << 24) | 0xffffff
 			text_color = (alpha << 24) | @text_color
@@ -87,11 +138,42 @@ module AGL
 		end
 	end
 	
+	# This class represents a text field (input).
 	class TextField
+		# The current text inside the text field.
 		attr_reader :text
 		
-		def initialize x, y, font, img, cursor_img = nil, margin_x = 0, margin_y = 0, max_length = 100, active = false,
-		               text = "", text_color = 0, selection_color = 0
+		# Creates a new text field.
+		# Parameters:
+		# [x] The x-coordinate where the text field will be drawn in the screen.
+		# [y] The y-coordinate where the text field will be drawn in the screen.
+		# [font] The <code>Gosu::Font</code> object that will be used to draw the
+		#        text inside the field.
+		# [img] The image of the text field. For a good result, you would likely
+		#       want something like a rectangle, horizontally wide, vertically
+		#       short, and with a color that contrasts with the +text_color+.
+		# [cursor_img] An image for the blinking cursor that stands in the point
+		#              where text will be inserted. If +nil+, a simple black line
+		#              will be drawn instead.
+		# [text_color] Color of the button text, in hexadecimal RRGGBB format.
+		# [margin_x] The x offset, from the field x-coordinate, to draw the text.
+		# [margin_y] The y offset, from the field y-coordinate, to draw the text.
+		# [max_length] The maximum length of the text inside the field.
+		# [active] Whether the text field must be focused by default. If +false+,
+		#          focus can be granted by clicking inside the text field or by
+		#          calling the +focus+ method.
+		# [text] The starting text. Must not be +nil+.
+		# [allowed_chars] A string containing all characters that can be typed
+		#                 inside the text field. The complete set of supported
+		#                 characters is given by the string
+		#                 <code>"abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ'-=/[]\\\\,.;\"_+?{}|<>:!@#$%¨&*()"</code>.
+		# [text_color] The color with which the text will be drawn, in hexadecimal
+		#              RRGGBB format.
+		# [selection_color] The color of the rectangle highlighting selected text,
+		#                   in hexadecimal RRGGBB format. The rectangle will
+		#                   always be drawn with 50% of opacity.
+		def initialize x, y, font, img, cursor_img = nil, margin_x = 0, margin_y = 0, max_length = 100, active = false, text = "",
+		               allowed_chars = nil, text_color = 0, selection_color = 0
 			@x = x
 			@y = y
 			@font = font
@@ -128,41 +210,16 @@ module AGL
 				Gosu::KbBracketRight, Gosu::KbBackslash, Gosu::KbApostrophe,
 				Gosu::KbComma, Gosu::KbPeriod, Gosu::KbSlash
 			]
-			@chars = "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ'-=/[]\\,.;\"_+?{}|<>:!@#$%6&*()"
-		end
-		
-		def text= value
-			@text = value[0...max_length]
-			@nodes.clear; @nodes << (@x + @margin_x)
-			x = @nodes[0]
-			for char in @text
-				x += @font.text_width char
-				@nodes << x
-			end
-			@cur_node = @nodes.size - 1
-			@anchor1 = nil
-			@anchor2 = nil
-			set_cursor_visible
-		end
-		
-		def selected_text
-			return "" if @anchor2.nil?
-			min = @anchor1 < @anchor2 ? @anchor1 : @anchor2
-			max = min == @anchor1 ? @anchor2 : @anchor1
-			@text[min..max]
-		end
-		
-		def focus
-			@active = true
-		end
-		
-		def unfocus
-			@anchor1 = @anchor2 = nil
-			@cursor_visible = false
-			@cursor_timer = 0
-			@active = false
+			@chars = "abcdefghijklmnopqrstuvwxyz1234567890 ABCDEFGHIJKLMNOPQRSTUVWXYZ'-=/[]\\,.;\"_+?{}|<>:!@#$%¨&*()"
+			@allowed_chars =
+				if allowed_chars
+					allowed_chars
+				else
+					@chars
+				end
 		end
 		
+		# Updates the text field, checking for mouse events and keyboard input.
 		def update
 			################################ Mouse ################################
 			if Mouse.over? @x, @y, @w, @h
@@ -321,6 +378,66 @@ module AGL
 			end
 		end
 		
+		# Sets the text of the text field to the specified value.
+		# Parameters:
+		# [value] The new text to be set. If it's longer than the +max_length+
+		#         parameter used in the constructor, it will be truncated to
+		#         +max_length+ characters.
+		def text= value
+			@text = value[0...max_length]
+			@nodes.clear; @nodes << (@x + @margin_x)
+			x = @nodes[0]
+			for char in @text
+				x += @font.text_width char
+				@nodes << x
+			end
+			@cur_node = @nodes.size - 1
+			@anchor1 = nil
+			@anchor2 = nil
+			set_cursor_visible
+		end
+		
+		# Returns the currently selected text.
+		def selected_text
+			return "" if @anchor2.nil?
+			min = @anchor1 < @anchor2 ? @anchor1 : @anchor2
+			max = min == @anchor1 ? @anchor2 : @anchor1
+			@text[min..max]
+		end
+		
+		# Grants focus to the text field, so that it allows keyboard input.
+		def focus
+			@active = true
+		end
+		
+		# Removes focus from the text field, so that no keyboard input will be
+		# accepted.
+		def unfocus
+			@anchor1 = @anchor2 = nil
+			@cursor_visible = false
+			@cursor_timer = 0
+			@active = false
+		end
+		
+		# Sets the position of the text field in the screen.
+		# Parameters:
+		# [x] The new x-coordinate for the text field.
+		# [y] The new y-coordinate for the text field.
+		def set_position x, y
+			d_x = x - @x
+			d_y = y - @y
+			@x = x; @y = y
+			@text_x += d_x
+			@text_y += d_y
+			@nodes.map! do |n|
+				n + d_x
+			end
+		end
+		
+		# Draws the text field in the screen.
+		# Parameters:
+		# [alpha] The opacity with which the text field will be drawn. Allowed
+		#         values vary between 0 (fully transparent) and 255 (fully opaque).
 		def draw alpha = 0xff
 			color = (alpha << 24) | 0xffffff
 			text_color = (alpha << 24) | @text_color
@@ -371,6 +488,7 @@ module AGL
 		end
 		
 		def insert_char char
+			return unless @allowed_chars.index char
 			if @text.length < @max_length
 				@text.insert @cur_node, char
 				@nodes.insert @cur_node + 1, @nodes[@cur_node] + @font.text_width(char)

data/lib/minigl/game_object.rb

@@ -1,10 +1,34 @@
 require_relative 'movement'
 
 module AGL
+	# This class represents an (optionally animated) image inside the game screen.
 	class Sprite
+		# The index of the current sprite in the spritesheet being drawn.
 		attr_reader :img_index
-		attr_accessor :x, :y
 		
+		# The x-coordinate of the image in the screen.
+		attr_accessor :x
+		
+		# The y-coordinate of the image in the screen.
+		attr_accessor :y
+		
+		# Creates a new sprite.
+		# Parameters:
+		# [x] The x-coordinate where the sprite will be drawn in the screen.
+		# [y] The y-coordinate where the sprite will be drawn in the screen.
+		# [img] The path to a PNG image or spritesheet, following the MiniGL
+		#       convention: images must be inside a 'data/img' directory, relative
+		#       to the code file, and you must only provide the file name, without
+		#       extension, in this case. If the image is inside a subdirectory of
+		#       'data/img', you must prefix the file name with each subdirectory
+		#       name, followed by an underscore (so the file and directories names
+		#       must not contain underscores). For example, if your image is
+		#       'data/img/sprite/1.png', you must provide <code>"sprite_1"</code>
+		#       or +:sprite_1+.
+		# [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
+		#               image is not a spritesheet.
+		# [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
+		#               image is not a spritesheet.
 		def initialize x, y, img, sprite_cols = nil, sprite_rows = nil
 			@x = x; @y = y
 			@img =
@@ -18,6 +42,16 @@ module AGL
 			@index_index = 0
 		end
 		
+		# Performs time checking to update the image index according to the
+		# sequence of indices and the interval.
+		# Parameters:
+		# [indices] The sequence of image indices used in the animation. The
+		#           indices are determined from left to right, and from top to
+		#           bottom, inside the spritesheet. All indices must be in the
+		#           interval <code>0..(sprite_cols * sprite_rows)</code>.
+		# [interval] The amount of frames between each change in the image index.
+		#            A frame will usually represent 1/60 second (roughly 17
+		#            milliseconds).
 		def animate indices, interval
 			@anim_counter += 1
 			if @anim_counter >= interval
@@ -28,6 +62,22 @@ module AGL
 			end
 		end
 		
+		# Draws the sprite in the screen
+		# Parameters:
+		# [map] A Map object, relative to which the sprite will be drawn (the x
+		#       and y coordinates of the sprite will be changed according to the
+		#       position of the camera).
+		# [scale_x] A scale factor to be applied horizontally to the image.
+		# [scale_y] A scale factor to be applied vertically to the image.
+		# [alpha] The opacity with which the image will be drawn. Valid values
+		#         vary from 0 (fully transparent) to 255 (fully opaque).
+		# [color] A color filter to apply to the image. A white (0xffffff) filter
+		#         will keep all colors unchanged, while a black (0x000000) filter
+		#         will turn all colors to black. A red (0xff0000) filter will keep
+		#         reddish colors with slight or no change, whereas bluish colors
+		#         will be darkened, for example.
+		# [angle] A rotation, in degrees, to be applied to the image, relative to
+		#         its center.
 		def draw map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil
 			color = (alpha << 24) | color
 			if map
@@ -43,10 +93,29 @@ module AGL
 			end
 		end
 	end
-
+	
+	# This class represents an object with a set of properties and methods
+	# commonly used in games. It defines an object with a rectangular bounding
+	# box, and having all the attributes required for using the Movement module.
 	class GameObject < Sprite
 		include Movement
 		
+		# Creates a new game object.
+		# Parameters:
+		# [x] The x-coordinate of the object's bounding box.
+		# [y] The y-coordinate of the object's bounding box.
+		# [w] The width of the object's bounding box.
+		# [h] The height of the object's bounding box.
+		# [img] The image or spritesheet for the object.
+		# [img_gap] A Vector object representing the difference between the top
+		#           left corner of the bounding box and the coordinates of the
+		#           image. For example, an object with <code>x = 100</code>,
+		#           <code>y = 50</code> and <code>img_gap = Vector.new(-5, -5)</code>
+		#           will be drawn at position (95, 45) of the screen.
+		# [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
+		#               image is not a spritesheet.
+		# [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
+		#               image is not a spritesheet.
 		def initialize x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil
 			super x, y, img, sprite_cols, sprite_rows
 			@w = w; @h = h
@@ -62,17 +131,37 @@ module AGL
 			@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
 		
-		def is_visible map
+		def is_visible map # :nodoc:
 			return map.cam.intersects @active_bounds if @active_bounds
 			false
 		end
 		
+		# Draws the game object in the screen.
+		# Parameters:
+		# [map] A Map object, relative to which the object will be drawn (the x
+		#       and y coordinates of the image will be changed according to the
+		#       position of the camera).
+		# [scale_x] A scale factor to be applied horizontally to the image.
+		# [scale_y] A scale factor to be applied vertically to the image.
+		# [alpha] The opacity with which the image will be drawn. Valid values
+		#         vary from 0 (fully transparent) to 255 (fully opaque).
+		# [color] A color filter to apply to the image. A white (0xffffff) filter
+		#         will keep all colors unchanged, while a black (0x000000) filter
+		#         will turn all colors to black. A red (0xff0000) filter will keep
+		#         reddish colors with slight or no change, whereas bluish colors
+		#         will be darkened, for example.
+		# [angle] A rotation, in degrees, to be applied to the image, relative to
+		#         its center.
 		def draw map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil
 			color = (alpha << 24) | color
 			if map
@@ -91,6 +180,7 @@ module AGL
 		end
 	end
 	
+	# :nodoc: all
 	class Effect < Sprite
 		def initialize x, y, life_time, img, sprite_cols = nil, sprite_rows = nil, indices = nil, interval = 1
 			super x, y, img, sprite_cols, sprite_rows

data/lib/minigl/global.rb

@@ -1,21 +1,66 @@
 require 'gosu'
 
+# The main module of the library, used only as a namespace.
 module AGL
+	# A Struct with two attributes, x and y (in this order), representing a point
+	# in a bidimensional space.
 	Vector = Struct.new :x, :y
 	
+	# This class represents a rectangle by its x and y coordinates and width and
+	# height.
 	class Rectangle
-		attr_accessor :x, :y, :w, :h
+		# The x-coordinate of the rectangle.
+		attr_accessor :x
 		
+		# The y-coordinate of the rectangle.
+		attr_accessor :y
+		
+		# The width of the rectangle.
+		attr_accessor :w
+		
+		# The height of the rectangle.
+		attr_accessor :h
+		
+		# Creates a new rectangle.
+		# Parameters:
+		# [x] The x-coordinate of the rectangle.
+		# [y] The y-coordinate of the rectangle.
+		# [w] The width of the rectangle.
+		# [h] The height of the rectangle.
 		def initialize x, y, w, h
 			@x = x; @y = y; @w = w; @h = h
 		end
 		
+		# Returns whether this rectangle intersects another.
+		# Parameters:
+		# [r] The rectangle to check intersection with.
 		def intersects r
 			@x < r.x + r.w && @x + @w > r.x && @y < r.y + r.h && @y + @h > r.y
 		end
 	end
 	
+	# The main class for a MiniGL game, holds references to globally accessible
+	# objects and constants.
 	class Game
+		# Initializes a MiniGL game. This method must be called before any feature
+		# provided by the library can be used.
+		# Parameters:
+		# [window] An instance of a class which inherits from
+		#          <code>Gosu::Window</code>. This will be the game window, used
+		#          to draw everything and capture user input.
+		# [gravity] A Vector object representing the horizontal and vertical
+		#           components of the force of gravity. Essentially, this force
+		#           will be applied to every object which calls +move+, from the
+		#           Movement module.
+		# [kb_held_delay] The number of frames a key must be held by the user
+		#                 before the "held" event (that can be checked with
+		#                 <code>KB.key_held?</code>) starts to trigger.
+		# [kb_held_interval] The interval, in frames, between each triggering of
+		#                    the "held" event, after the key has been held for
+		#                    more than +kb_held_delay+ frames.
+		# [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 self.initialize window, gravity = Vector.new(0, 1),
 		                    kb_held_delay = 40, kb_held_interval = 5,
 		                    double_click_delay = 8
@@ -30,16 +75,29 @@ module AGL
 			Res.initialize
 		end
 		
+		# Returns a reference to the game window.
 		def self.window; @@window; end
+		
+		# Returns a Vector representing the force of gravity. See +initialize+ for
+		# details.
 		def self.gravity; @@gravity; end
+		
+		# Returns the value of kb_held_delay. See +initialize+ for details.
 		def self.kb_held_delay; @@kb_held_delay; end
+		
+		# Returns the value of kb_held_interval. See +initialize+ for details.
 		def self.kb_held_interval; @@kb_held_interval; end
+		
+		# Returns the value of double_click_delay. See +initialize+ for details.
 		def self.double_click_delay; @@double_click_delay; end
 	end
 	
 	#class JSHelper
 	
+	# Exposes methods for controlling keyboard events.
 	class KB
+		# This is called by <code>Game.initialize</code>. Don't call it
+		# explicitly.
 		def self.initialize
 			@@keys = [
 				Gosu::KbUp, Gosu::KbDown,
@@ -66,6 +124,7 @@ module AGL
 			@@held_interval = {}
 		end
 		
+		# Updates the state of all keys.
 		def self.update
 			@@held_timer.each do |k, v|
 				if v < Game.kb_held_delay; @@held_timer[k] += 1
@@ -93,24 +152,58 @@ module AGL
 			end
 		end
 		
+		# Returns whether the given key is down in the current frame and was not
+		# down in the frame before.
+		# Parameters:
+		# [key] Code of the key to be checked. The available codes are <code>
+		#       Gosu::KbUp, Gosu::KbDown, Gosu::KbReturn, Gosu::KbEscape,
+		#       Gosu::KbLeftControl, Gosu::KbRightControl,
+		#       Gosu::KbA, Gosu::KbB, Gosu::KbC, Gosu::KbD, Gosu::KbE, Gosu::KbF,
+		#       Gosu::KbG, Gosu::KbH, Gosu::KbI, Gosu::KbJ, Gosu::KbK, Gosu::KbL,
+		#       Gosu::KbM, Gosu::KbN, Gosu::KbO, Gosu::KbP, Gosu::KbQ, Gosu::KbR,
+		#       Gosu::KbS, Gosu::KbT, Gosu::KbU, Gosu::KbV, Gosu::KbW, Gosu::KbX,
+		#       Gosu::KbY, Gosu::KbZ, Gosu::Kb1, Gosu::Kb2, Gosu::Kb3, Gosu::Kb4,
+		#       Gosu::Kb5, Gosu::Kb6, Gosu::Kb7, Gosu::Kb8, Gosu::Kb9, Gosu::Kb0,
+		#       Gosu::KbNumpad1, Gosu::KbNumpad2, Gosu::KbNumpad3, Gosu::KbNumpad4,
+		#       Gosu::KbNumpad5, Gosu::KbNumpad6, Gosu::KbNumpad7, Gosu::KbNumpad8,
+		#       Gosu::KbNumpad9, Gosu::KbNumpad0, Gosu::KbSpace, Gosu::KbBackspace,
+		#       Gosu::KbDelete, Gosu::KbLeft, Gosu::KbRight, Gosu::KbHome,
+		#       Gosu::KbEnd, Gosu::KbLeftShift, Gosu::KbRightShift,
+		#       Gosu::KbBacktick, Gosu::KbMinus, Gosu::KbEqual, Gosu::KbBracketLeft,
+		#       Gosu::KbBracketRight, Gosu::KbBackslash, Gosu::KbApostrophe,
+		#       Gosu::KbComma, Gosu::KbPeriod, Gosu::KbSlash</code>.
 		def self.key_pressed? key
 			@@prev_down.index(key).nil? and @@down.index(key)
 		end
 		
+		# Returns whether the given key is down in the current frame.
+		# Parameters:
+		# [key] Code of the key to be checked. See +key_pressed?+ for details.
 		def self.key_down? key
 			@@down.index(key)
 		end
 		
+		# Returns whether the given key is not down in the current frame but was
+		# down in the frame before.
+		# Parameters:
+		# [key] Code of the key to be checked. See +key_pressed?+ for details.
 		def self.key_released? key
 			@@prev_down.index(key) and @@down.index(key).nil?
 		end
 		
+		# Returns whether the given key is being held down. See
+		# <code>Game.initialize</code> for details.
+		# Parameters:
+		# [key] Code of the key to be checked. See +key_pressed?+ for details.
 		def self.key_held? key
 			@@held_interval[key] == Game.kb_held_interval
 		end
 	end
 	
+	# Exposes methods for controlling mouse events.
 	class Mouse
+		# This is called by <code>Game.initialize</code>. Don't call it
+		# explicitly.
 		def self.initialize
 			@@down = {}
 			@@prev_down = {}
@@ -118,6 +211,7 @@ module AGL
 			@@dbl_click_timer = {}
 		end
 		
+		# Updates the mouse position and the state of all buttons.
 		def self.update
 			@@prev_down = @@down.clone
 			@@down.clear
@@ -144,31 +238,71 @@ module AGL
 			@@y = Game.window.mouse_y.round
 		end
 		
+		# Returns the x-coordinate of the mouse cursor in the screen.
 		def self.x; @@x; end
+		
+		# Returns the y-coordinate of the mouse cursor in the screen.
 		def self.y; @@y; end
 		
+		# Returns whether the given button is down in the current frame and was
+		# not down in the frame before.
+		# Parameters:
+		# [btn] Button to be checked. Valid values are +:left+, +:middle+ and
+		#       +:right+
 		def self.button_pressed? btn
 			@@down[btn] and not @@prev_down[btn]
 		end
 		
+		# Returns whether the given button is down in the current frame.
+		# Parameters:
+		# [btn] Button to be checked. Valid values are +:left+, +:middle+ and
+		#       +:right+
 		def self.button_down? btn
 			@@down[btn]
 		end
 		
+		# Returns whether the given button is not down in the current frame, but
+		# was down in the frame before.
+		# Parameters:
+		# [btn] Button to be checked. Valid values are +:left+, +:middle+ and
+		#       +:right+
 		def self.button_released? btn
 			@@prev_down[btn] and not @@down[btn]
 		end
 		
+		# Returns whether the given button has just been double clicked.
+		# Parameters:
+		# [btn] Button to be checked. Valid values are +:left+, +:middle+ and
+		#       +:right+
 		def self.double_click? btn
 			@@dbl_click[btn]
 		end
 		
+		# Returns whether the mouse cursor is currently inside the given area.
+		# Parameters:
+		# [x] The x-coordinate of the top left corner of the area.
+		# [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 self.over? x, y, w, h
 			@@x >= x and @@x < x + w and @@y >= y and @@y < y + h
 		end
 	end
 	
+	# This class is responsible for resource management. It keeps references to
+	# all loaded resources until a call to +clear+ is made. Resources can be
+	# loaded as global, so that their references won't be removed even when
+	# +clear+ is called.
+	#
+	# It also provides an easier syntax for loading resources, assuming a
+	# particular folder structure. All resources must be inside subdirectories
+	# of a 'data' directory, so that you will only need to specify the type of
+	# resource being loaded and the file name (either as string or as symbol).
+	# There are default extensions for each type of resource, so the extension
+	# must be specified only if the file is in a format other than the default.
 	class Res
+		# This is called by <code>Game.initialize</code>. Don't call it
+		# explicitly.
 		def self.initialize
 			@@imgs = Hash.new
 			@@global_imgs = Hash.new
@@ -176,10 +310,28 @@ module AGL
 			@@global_tilesets = Hash.new
 			@@sounds = Hash.new
 			@@global_sounds = Hash.new
+			@@songs = Hash.new
+			@@global_songs = Hash.new
 			@@fonts = Hash.new
 			@@global_fonts = Hash.new
 		end
 		
+		# Returns a <code>Gosu::Image</code> object.
+		# Parameters:
+		# [id] A string or symbol representing the path to the image. If the file
+		#      is inside 'data/img', only the file name is needed. If it's inside
+		#      a subdirectory, the id must be prefixed by each subdirectory name
+		#      followed by an underscore. Example: to load
+		#      'data/img/sprite/1.png', provide +:sprite_1+ or "sprite_1".
+		# [global] Set to true if you want to keep the image in memory until the
+		#          game execution is finished. If false, the image will be
+		#          released when you call +clear+.
+		# [tileable] Whether the image should be loaded in tileable mode, which is
+		#            proper for images that will be used as a tile, i.e., that
+		#            will be drawn repeated times, side by side, forming a
+		#            continuous composition.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".png".
 		def self.img id, global = false, tileable = false, ext = ".png"
 			if global; a = @@global_imgs; else; a = @@imgs; end
 			return a[id] if a[id]
@@ -188,6 +340,20 @@ module AGL
 			a[id] = img
 		end
 		
+		# Returns an array of <code>Gosu::Image</code> objects, using the image as
+		# a spritesheet. The image with index 0 will be the top left sprite, and
+		# the following indices raise first from left to right and then from top
+		# to bottom.
+		# Parameters:
+		# [id] A string or symbol representing the path to the image. See +img+
+		#      for details.
+		# [sprite_cols] Number of columns in the spritesheet.
+		# [sprite_rows] Number of rows in the spritesheet.
+		# [global] Set to true if you want to keep the image in memory until the
+		#          game execution is finished. If false, the image will be
+		#          released when you call +clear+.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".png".
 		def self.imgs id, sprite_cols, sprite_rows, global = false, ext = ".png"
 			if global; a = @@global_imgs; else; a = @@imgs; end
 			return a[id] if a[id]
@@ -196,6 +362,21 @@ module AGL
 			a[id] = imgs
 		end
 		
+		# Returns an array of <code>Gosu::Image</code> objects, using the image as
+		# a tileset. Works the same as +imgs+, except you must provide the tile
+		# size instead of the number of columns and rows, and that the images will
+		# be loaded as tileable.
+		# Parameters:
+		# [id] A string or symbol representing the path to the image. It must be
+		#      specified the same way as in +img+, but the base directory is
+		#      'data/tileset'.
+		# [tile_width] Width of each tile, in pixels.
+		# [tile_height] Height of each tile, in pixels.
+		# [global] Set to true if you want to keep the image in memory until the
+		#          game execution is finished. If false, the image will be
+		#          released when you call +clear+.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".png".
 		def self.tileset id, tile_width = 32, tile_height = 32, global = false, ext = ".png"
 			if global; a = @@global_tilesets; else; a = @@tilesets; end
 			return a[id] if a[id]
@@ -204,6 +385,17 @@ module AGL
 			a[id] = tileset
 		end
 		
+		# Returns a <code>Gosu::Sample</code> object. This should be used for
+		# simple and short sound effects.
+		# Parameters:
+		# [id] A string or symbol representing the path to the sound. It must be
+		#      specified the same way as in +img+, but the base directory is
+		#      'data/sound'.
+		# [global] Set to true if you want to keep the sound in memory until the
+		#          game execution is finished. If false, the sound will be
+		#          released when you call +clear+.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".wav".
 		def self.sound id, global = false, ext = ".wav"
 			if global; a = @@global_sounds; else; a = @@sounds; end
 			return a[id] if a[id]
@@ -212,14 +404,39 @@ module AGL
 			a[id] = sound
 		end
 		
+		# Returns a <code>Gosu::Song</code> object. This should be used for the
+		# background musics of your game.
+		# Parameters:
+		# [id] A string or symbol representing the path to the song. It must be
+		#      specified the same way as in +img+, but the base directory is
+		#      'data/song'.
+		# [global] Set to true if you want to keep the song in memory until the
+		#          game execution is finished. If false, the song will be released
+		#          when you call +clear+.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".ogg".
 		def self.song id, global = false, ext = ".ogg"
-			if global; a = @@global_sounds; else; a = @@sounds; end
+			if global; a = @@global_songs; else; a = @@songs; end
 			return a[id] if a[id]
 			s = "data/song/" + id.to_s.split('_').join('/') + ext
 			song = Gosu::Song.new Game.window, s
 			a[id] = song
 		end
 		
+		# Returns a <code>Gosu::Font</code> object. Fonts are needed to draw text
+		# and used by MiniGL elements like buttons, text fields and TextHelper
+		# objects.
+		# Parameters:
+		# [id] A string or symbol representing the path to the song. It must be
+		#      specified the same way as in +img+, but the base directory is
+		#      'data/font'.
+		# [size] The size of the font, in pixels. This will correspond,
+		#        approximately, to the height of the tallest character when drawn.
+		# [global] Set to true if you want to keep the font in memory until the
+		#          game execution is finished. If false, the font will be released
+		#          when you call +clear+.
+		# [ext] The extension of the file being loaded. Specify only if it is
+		#       other than ".ttf".
 		def self.font id, size, global = true, ext = ".ttf"
 			if global; a = @@global_fonts; else; a = @@fonts; end
 			id_size = "#{id}_#{size}"
@@ -229,14 +446,12 @@ module AGL
 			a[id_size] = font
 		end
 		
-#		def self.text id
-#			G.texts[G.lang][id.to_sym]
-#		end
-		
+		# Releases the memory used by all non-global resources.
 		def self.clear
 			@@imgs.clear
 			@@tilesets.clear
 			@@sounds.clear
+			@@songs.clear
 			@@fonts.clear
 		end
 	end

data/lib/minigl/map.rb

@@ -1,9 +1,28 @@
 require_relative 'global'
 
 module AGL
+	# This class provides easy control of a tile map, i.e., a map consisting of
+	# a grid of equally sized tiles. It also provides viewport control, through
+	# its camera property and methods.
 	class Map
-		attr_reader :tile_size, :size, :cam
+		# A Vector where x is the tile width and y is the tile height.
+		attr_reader :tile_size
 		
+		# A Vector where x is the horizontal tile count and y the vertical count.
+		attr_reader :size
+		
+		# A Rectangle representing the region of the map that is currently
+		# visible.
+		attr_reader :cam
+		
+		# Creates a new map.
+		# Parameters:
+		# [t_w] The width of the tiles.
+		# [t_h] The height of the tiles.
+		# [t_x_count] The horizontal count of tiles in the map.
+		# [t_y_count] The vertical count of tiles in the map.
+		# [scr_w] Width of the viewport for the map.
+		# [scr_h] Height of the viewport for the map.
 		def initialize t_w, t_h, t_x_count, t_y_count, scr_w = 800, scr_h = 600
 			@tile_size = Vector.new t_w, t_h
 			@size = Vector.new t_x_count, t_y_count
@@ -12,38 +31,79 @@ module AGL
 			@max_y = t_y_count * t_h - scr_h
 		end
 		
+		# Returns a Vector with the total size of the map, in pixels (x for the
+		# width and y for the height).
 		def get_absolute_size
 			Vector.new(@tile_size.x * @size.x, @tile_size.y * @size.y)
 		end
 		
+		# Returns a Vector with the coordinates of the center of the map.
 		def get_center
 			Vector.new(@tile_size.x * @size.x / 2, @tile_size.y * @size.y / 2)
 		end
 		
+		# Returns the position in the screen corresponding to the given tile
+		# indices.
+		# Parameters:
+		# [map_x] The index of the tile in the horizontal direction. It must be in
+		#         the interval <code>0..t_x_count</code>.
+		# [map_y] The index of the tile in the vertical direction. It must be in
+		#         the interval <code>0..t_y_count</code>.
 		def get_screen_pos map_x, map_y
 			Vector.new(map_x * @tile_size.x - @cam.x, map_y * @tile_size.y - @cam.y)
 		end
 		
+		# Returns the tile in the map that corresponds to the given position in
+		# the screen, as a Vector, where x is the horizontal index and y the
+		# vertical index.
+		# Parameters:
+		# [scr_x] The x-coordinate in the screen.
+		# [scr_y] The y-coordinate in the screen.
 		def get_map_pos scr_x, scr_y
 			Vector.new((scr_x + @cam.x) / @tile_size.x, (scr_y + @cam.y) / @tile_size.y)
 		end
 		
+		# Verifies whether a tile is inside the map.
+		# Parameters:
+		# [v] A Vector representing the tile, with x as the horizontal index and
+		#     y as the vertical index.
 		def is_in_map v
 			v.x >= 0 && v.y >= 0 && v.x < @size.x && v.y < @size.y
 		end
 		
+		# Sets the top left corner of the viewport to the given position of the
+		# map. Note that this is not the position in the screen.
+		# Parameters:
+		# [cam_x] The x-coordinate inside the map, in pixels (not a tile index).
+		# [cam_y] The y-coordinate inside the map, in pixels (not a tile index).
 		def set_camera cam_x, cam_y
 			@cam.x = cam_x
 			@cam.y = cam_y
 			set_bounds
 		end
 		
+		# Moves the viewport by the given amount of pixels.
+		# Parameters:
+		# [x] The amount of pixels to move horizontally. Negative values will
+		#     cause the camera to move to the left.
+		# [y] The amount of pixels to move vertically. Negative values will cause
+		#     the camera to move up.
 		def move_camera x, y
 			@cam.x += x
 			@cam.y += y
 			set_bounds
 		end
 		
+		# Iterates through the currently visible tiles, providing the horizontal
+		# tile index, the vertical tile index, the x-coordinate (in pixels) and
+		# the y-coordinate (in pixels), of each tile, in that order, to a given
+		# block of code.
+		#
+		# Example:
+		#
+		#   map.foreach do |i, j, x, y|
+		#     draw_tile tiles[i][j], x, y
+		#   end
 		def foreach
 			for j in @min_vis_y..@max_vis_y
 				for i in @min_vis_x..@max_vis_x

data/lib/minigl/movement.rb

@@ -1,20 +1,67 @@
 require_relative 'global'
 
 module AGL
+	# Represents an object with a rectangular bounding box and the +passable+
+	# property. It is the simplest structure that can be passed as an element of
+	# the +obst+ array parameter of the +move+ method.
 	class Block
-		attr_reader :x, :y, :w, :h, :passable
+		# The x-coordinate of the top left corner of the bounding box.
+		attr_reader :x
 		
+		# The y-coordinate of the top left corner of the bounding box.
+		attr_reader :y
+		
+		# The width of the bounding box.
+		attr_reader :w
+		
+		# The height of the bounding box.
+		attr_reader :h
+		
+		# Whether a moving object can pass through this block when coming from
+		# below. This is a common feature of platforms in platform games.
+		attr_reader :passable
+		
+		# Creates a new block.
+		# Parameters:
+		# [x] The x-coordinate of the top left corner of the bounding box.
+		# [y] The y-coordinate of the top left corner of the bounding box.
+		# [w] The width of the bounding box.
+		# [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
 			@x = x; @y = y; @w = w; @h = h
 			@passable = passable
 		end
 		
+		# Returns the bounding box of this block as a Rectangle.
 		def bounds
 			Rectangle.new @x, @y, @w, @h
 		end
 	end
 	
+	# Represents a ramp, i.e., an inclined structure which allows walking over
+	# it while automatically going up or down. It can be imagined as a right
+	# triangle, with a side parallel to the x axis and another one parallel to
+	# the y axis. You must provide instances of this class (or derived classes)
+	# to the +ramps+ array parameter of the +move+ method.
 	class Ramp
+		# Creates a new ramp.
+		# Parameters:
+		# [x] The x-coordinate of the top left corner of a rectangle that
+		#     completely (and precisely) encloses the ramp (thought of as a right
+		#     triangle).
+		# [y] The y-coordinate of the top left corner of the rectangle described
+		#     above.
+		# [w] The width of the ramp (which corresponds to the width of the
+		#     rectangle described above).
+		# [h] The height of the ramp (which corresponds to the height of the
+		#     rectangle described above, and to the difference between the lowest
+		#     point of the ramp, where it usually meets the floor, and the
+		#     highest).
+		# [left] Whether the height of the ramp increases from left to right. Use
+		#        +false+ for a ramp that goes down from left to right.
 		def initialize x, y, w, h, left
 			@x = x
 			@y = y
@@ -23,6 +70,24 @@ module AGL
 			@left = left
 		end
 		
+		# Checks if an object is in contact with this ramp (standing over it).
+		# Parameters:
+		# [obj] The object to check contact with. It must have the +x+, +y+, +w+
+		#       and +h+ accessible attributes determining its bounding box.
+		def contact? obj
+			obj.x.round(6) == get_x(obj).round(6) && obj.y.round(6) == get_y(obj).round(6)
+		end
+		
+		# Checks if an object is intersecting this ramp (inside the corresponding
+		# right triangle and at the floor level or above).
+		# Parameters:
+		# [obj] The object to check intersection with. It must have the +x+, +y+,
+		#       +w+ and +h+ accessible attributes determining its bounding box.
+		def intersects obj
+			obj.x + obj.w > @x && obj.x < @x + @w && obj.y > get_y(obj) && obj.y <= @y + @h - obj.h
+		end
+		
+		# :nodoc:
 		def can_collide? obj
 			@can_collide = (obj.speed.y >= 0 and not intersects(obj))
 		end
@@ -46,14 +111,6 @@ module AGL
 			end
 		end
 		
-		def contact? obj
-			obj.x.round(6) == get_x(obj).round(6) && obj.y.round(6) == get_y(obj).round(6)
-		end
-		
-		def intersects obj
-			obj.x + obj.w > @x && obj.x < @x + @w && obj.y > get_y(obj) && obj.y <= @y + @h - obj.h
-		end
-		
 		def get_x obj
 			return @x + (1.0 * (@y + @h - obj.y - obj.h) * @w / @h) - obj.w if @left
 			@x + (1.0 * (obj.y + obj.h - @y) * @w / @h)
@@ -67,14 +124,66 @@ module AGL
 		end
 	end
 	
+	# This module provides objects with physical properties and methods for
+	# moving. It allows moving with or without collision checking (based on
+	# rectangular bounding boxes), including a method to behave as an elevator,
+	# affecting other objects' positions as it moves.
 	module Movement
-		attr_reader :speed, :w, :h, :passable, :top, :bottom, :left, :right
-		attr_accessor :x, :y, :stored_forces
-	
+		# A Vector with the current speed of the object (x: horizontal component,
+		# y: vertical component).
+		attr_reader :speed
+		
+		# Width of the bounding box.
+		attr_reader :w
+		
+		# Height of the bounding box.
+		attr_reader :h
+		
+		# Whether a moving object can pass through this block when coming from
+		# below. This is a common feature of platforms in platform games.
+		attr_reader :passable
+		
+		# The object that is making contact with this from above. If there's no
+		# contact, returns +nil+.
+		attr_reader :top
+		
+		# The object that is making contact with this from below. If there's no
+		# contact, returns +nil+.
+		attr_reader :bottom
+		
+		# The object that is making contact with this from the left. If there's no
+		# contact, returns +nil+.
+		attr_reader :left
+		
+		# The object that is making contact with this from the right. If there's
+		# no contact, returns +nil+.
+		attr_reader :right
+		
+		# The x-coordinate of the top left corner of the bounding box.
+		attr_accessor :x
+		
+		# The y-coordinate of the top left corner of the bounding box.
+		attr_accessor :y
+		
+		# A Vector with the horizontal and vertical components of a force that
+		# be applied in the next time +move+ is called.
+		attr_accessor :stored_forces
+		
+		# Returns the bounding box as a Rectangle.
 		def bounds
 			Rectangle.new @x, @y, @w, @h
 		end
-	
+		
+		# Moves this object, based on the forces being applied to it, and
+		# performing collision checking.
+		# Parameters:
+		# [forces] A Vector where x is the horizontal component of the resulting
+		#          force and y is the vertical component.
+		# [obst] An array of obstacles to be considered in the collision checking.
+		#        Obstacles must be instances of Block (or derived classes), or
+		#        objects that <code>include Movement</code>.
+		# [ramps] An array of ramps to be considered in the collision checking.
+		#         Ramps must be instances of Ramp (or derived classes).
 		def move forces, obst, ramps
 			forces.x += Game.gravity.x; forces.y += Game.gravity.y
 			forces.x += @stored_forces.x; forces.y += @stored_forces.y
@@ -173,7 +282,17 @@ module AGL
 			end
 			check_contact obst, ramps
 		end
-	
+		
+		# Moves this object as an elevator (i.e., potentially carrying other
+		# objects) towards a given point.
+		# Parameters:
+		# [aim] A Vector specifying where the object will move to.
+		# [speed] The constant speed at which the object will move. This must be
+		#         provided as a scalar, not a vector.
+		# [obstacles] An array of obstacles to be considered in the collision
+		#             checking, and carried along when colliding from above.
+		#             Obstacles must be instances of Block (or derived classes),
+		#             or objects that <code>include Movement</code>.
 		def move_carrying aim, speed, obstacles
 			x_d = aim.x - @x; y_d = aim.y - @y
 			distance = Math.sqrt(x_d**2 + y_d**2)
@@ -206,7 +325,13 @@ module AGL
 		
 			passengers.each do |p| p.y = @y - p.h end
 		end
-	
+		
+		# Moves this object, without performing any collision checking, towards
+		# the specified point.
+		# Parameters:
+		# [aim] A Vector specifying where the object will move to.
+		# [speed] The constant speed at which the object will move. This must be
+		#         provided as a scalar, not a vector.
 		def move_free aim, speed
 			x_d = aim.x - @x; y_d = aim.y - @y
 			distance = Math.sqrt(x_d**2 + y_d**2)
@@ -227,7 +352,24 @@ module AGL
 				@y += @speed.y
 			end
 		end
-	
+		
+		# Causes the object to move in cycles across multiple given points (the
+		# method must be called repeatedly, and it returns the value that must be
+		# provided to +cur_point+ after the first call). If obstacles are
+		# provided, it will behave as an elevator (as in +move_carrying+).
+		# Parameters:
+		# [points] An array of Vectors representing the path that the object will
+		#          perform.
+		# [cur_point] The index of the point in the path that the object is
+		#             currently moving to. In the first call, it is a good idea to
+		#             provide 0, while in the subsequent calls, you must provide
+		#             the return value of this method.
+		# [speed] The constant speed at which the object will move. This must be
+		#         provided as a scalar, not a vector.
+		# [obstacles] An array of obstacles to be considered in the collision
+		#             checking, and carried along when colliding from above.
+		#             Obstacles must be instances of Block (or derived classes),
+		#             or objects that <code>include Movement</code>.
 		def cycle points, cur_point, speed, obstacles = nil
 			if obstacles
 				move_carrying points[cur_point], speed, obstacles

data/lib/minigl/text.rb

@@ -1,10 +1,32 @@
 module AGL
+	# This class provides methods for easily drawing one or multiple lines of
+	# text, with control over the text alignment and coloring.
 	class TextHelper
+		# Creates a TextHelper.
+		# Parameters:
+		# [font] A <code>Gosu::Font</code> that will be used to draw the text.
+		# [line_spacing] When drawing multiple lines, the distance, in pixels,
+		#                between each line.
 		def initialize font, line_spacing = 0
 			@font = font
 			@line_spacing = line_spacing
 		end
-	
+		
+		# Draws a single line of text.
+		# Parameters:
+		# [text] The text to be drawn. No line breaks are allowed.
+		# [x] The horizontal reference for drawing the text. If +mode+ is +:left+,
+		#     all text will be drawn from this point to the right; if +mode+ is
+		#     +:right+, all text will be drawn from this point to the left; and if
+		#     +mode+ is +:center+, the text will be equally distributed to the
+		#     left and to the right of this point.
+		# [y] The vertical reference for drawing the text. All text will be drawn
+		#     from this point down.
+		# [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).
 		def write_line text, x, y, mode = :left, color = 0, alpha = 0xff
 			color = (alpha << 24) | color
 			rel =
@@ -16,7 +38,23 @@ module AGL
 				end
 			@font.draw_rel text, x, y, 0, rel, 0, 1, 1, color
 		end
-	
+		
+		# Draws text, breaking lines when needed and when explicitly caused by the
+		# "\n" character.
+		# Parameters:
+		# [text] The text to be drawn. Line breaks are allowed.
+		# [x] The horizontal reference for drawing the text. Works like in
+		#     +write_line+ for the +:left+, +:right+ and +:center+ modes. For the
+		#     +:justified+ mode, works the same as for +:left+.
+		# [y] The vertical reference for drawing the text. All text will be drawn
+		#     from this point down.
+		# [width] The maximum width for the lines of text. Line is broken when
+		#         this width is exceeded.
+		# [mode] The alignment of the text. Valid values are +:left+, +:right+,
+		#        +:center+ and +:justified+.
+		# [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).
 		def write_breaking text, x, y, width, mode = :left, color = 0, alpha = 0xff
 			color = (alpha << 24) | color
 			text.split("\n").each do |p|

data/test/game.rb

@@ -11,8 +11,8 @@ class MyGame < Gosu::Window
     
     @font = Res.font :font1, 20
     @writer = TextHelper.new @font, 5
-    @btn = Button.new(10, 560, @font, "Test", :btn, 0x008000, false, 15, 5) {}
-    @txt = TextField.new 10, 520, @font, :text, nil, 15, 5, 16, false, "", 0, 0x0000ff
+    @btn = Button.new(10, 560, @font, "Test", :btn, 0x008000) {}
+    @txt = TextField.new 10, 520, @font, :text, nil, 15, 5, 16, false, "", nil, 0, 0x0000ff
   end
   
   def needs_cursor?
@@ -25,6 +25,8 @@ class MyGame < Gosu::Window
     @obj1.x += 1 if KB.key_down? Gosu::KbRight
     @obj1.y += 1 if KB.key_held? Gosu::KbDown
     @obj1.x -= 1 if KB.key_down? Gosu::KbLeft
+    @btn.set_position rand(700), rand(550) if KB.key_pressed? Gosu::KbSpace
+    @txt.set_position rand(700), rand(550) if KB.key_pressed? Gosu::KbReturn
     
     Mouse.update
     if Mouse.double_click? :left

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minigl
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.6
 platform: ruby
 authors:
 - Victor David Santos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-06 00:00:00.000000000 Z
+date: 2014-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu