minigl 1.0.1

data/lib/minigl/map.rb

@@ -0,0 +1,81 @@
+require_relative 'global'
+
+module AGL
+	class Map
+		attr_reader :tile_size, :size, :cam
+	
+		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
+			@cam = Rectangle.new 0, 0, scr_w, scr_h
+			@max_x = t_x_count * t_w - scr_w
+			@max_y = t_y_count * t_h - scr_h
+		end
+	
+		def get_absolute_size
+			Vector.new(@tile_size.x * @size.x, @tile_size.y * @size.y)
+		end
+	
+		def get_center
+			Vector.new(@tile_size.x * @size.x / 2, @tile_size.y * @size.y / 2)
+		end
+	
+		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
+	
+		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
+	
+		def is_in_map v
+			v.x >= 0 && v.y >= 0 && v.x < @size.x && v.y < @size.y
+		end
+	
+		def set_camera cam_x, cam_y
+			@cam.x = cam_x
+			@cam.y = cam_y
+			set_bounds
+		end
+	
+		def move_camera x, y
+			@cam.x += x
+			@cam.y += y
+			set_bounds
+		end
+	
+		def set_bounds
+			@cam.x = @cam.x.round
+			@cam.y = @cam.y.round
+			@cam.x = 0 if @cam.x < 0
+			@cam.x = @max_x if @cam.x > @max_x
+			@cam.y = 0 if @cam.y < 0
+			@cam.y = @max_y if @cam.y > @max_y
+		
+			@min_vis_x = @cam.x / @tile_size.x
+			@min_vis_y = @cam.y / @tile_size.y
+			@max_vis_x = (@cam.x + @cam.w - 1) / @tile_size.x
+			@max_vis_y = (@cam.y + @cam.h - 1) / @tile_size.y
+
+			if @min_vis_y < 0; @min_vis_y = 0
+			elsif @min_vis_y > @size.y - 1; @min_vis_y = @size.y - 1; end
+
+			if @max_vis_y < 0; @max_vis_y = 0
+			elsif @max_vis_y > @size.y - 1; @max_vis_y = @size.y - 1; end
+
+			if @min_vis_x < 0; @min_vis_x = 0
+			elsif @min_vis_x > @size.x - 1; @min_vis_x = @size.x - 1; end
+
+			if @max_vis_x < 0; @max_vis_x = 0
+			elsif @max_vis_x > @size.x - 1; @max_vis_x = @size.x - 1; end
+		end
+	
+		def foreach
+			for j in @min_vis_y..@max_vis_y
+				for i in @min_vis_x..@max_vis_x
+					yield i, j, i * @tile_size.x - @cam.x, j * @tile_size.y - @cam.y
+				end
+			end
+		end
+	end
+end

data/lib/minigl/movement.rb

@@ -0,0 +1,290 @@
+require_relative 'global'
+
+module AGL
+	class Block
+		attr_reader :x, :y, :w, :h, :passable
+		
+		def initialize x, y, w, h, passable
+			@x = x; @y = y; @w = w; @h = h
+			@passable = passable
+		end
+		
+		def bounds
+			Rectangle.new @x, @y, @w, @h
+		end
+	end
+	
+	class Ramp
+		def initialize x, y, w, h, left
+			@x = x
+			@y = y
+			@w = w
+			@h = h
+			@left = left
+		end
+		
+		def can_collide? obj
+			@can_collide = (obj.speed.y >= 0 and not intersects(obj))
+		end
+		
+		def check_intersection obj
+			if @can_collide and intersects obj
+				obj.y = get_y obj
+				obj.speed.y = 0
+#				a = @w / @h
+#				x = get_x(obj)
+#				y = get_y(obj)
+#				w = obj.x - x
+#				h = obj.y - y
+#				dx = w * h / (w * a + h)
+#				dy = dx * a
+#				
+#				obj.x -= dx
+#				obj.y -= dy
+#				obj.speed.x *= (@w / (@w + @h))
+#				obj.speed.y = 0
+			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)
+		end
+		
+		def get_y obj
+			return @y - obj.h if @left && obj.x + obj.w > @x + @w
+			return @y + (1.0 * (@x + @w - obj.x - obj.w) * @h / @w) - obj.h if @left
+			return @y - obj.h if obj.x < @x
+			@y + (1.0 * (obj.x - @x) * @h / @w) - obj.h
+		end
+	end
+	
+	module Movement
+		attr_reader :speed, :w, :h, :passable, :top, :bottom, :left, :right
+		attr_accessor :x, :y, :stored_forces
+	
+		def bounds
+			Rectangle.new @x, @y, @w, @h
+		end
+	
+		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
+			@stored_forces.x = @stored_forces.y = 0
+		
+			# check_contact obst, ramps
+			forces.x = 0 if (forces.x < 0 and @left) or (forces.x > 0 and @right)
+			forces.y = 0 if (forces.y < 0 and @top) or (forces.y > 0 and @bottom)
+		
+			@speed.x += forces.x; @speed.y += forces.y
+			@speed.x = 0 if @speed.x.abs < @min_speed.x
+			@speed.y = 0 if @speed.y.abs < @min_speed.y
+			@speed.x = (@speed.x <=> 0) * @max_speed.x if @speed.x.abs > @max_speed.x
+			@speed.y = (@speed.y <=> 0) * @max_speed.y if @speed.y.abs > @max_speed.y
+			
+			ramps.each do |r|
+				r.can_collide? self
+			end
+			
+			x = @speed.x < 0 ? @x + @speed.x : @x
+			y = @speed.y < 0 ? @y + @speed.y : @y
+			w = @w + (@speed.x < 0 ? -@speed.x : @speed.x)
+			h = @h + (@speed.y < 0 ? -@speed.y : @speed.y)
+			move_bounds = Rectangle.new x, y, w, h
+			coll_list = []
+			obst.each do |o|
+				coll_list << o if move_bounds.intersects o.bounds
+			end
+		
+			if coll_list.length > 0
+				up = @speed.y < 0; rt = @speed.x > 0; dn = @speed.y > 0; lf = @speed.x < 0
+				if @speed.x == 0 || @speed.y == 0
+					# Ortogonal
+					if rt; x_lim = find_right_limit coll_list
+					elsif lf; x_lim = find_left_limit coll_list
+					elsif dn; y_lim = find_down_limit coll_list
+					elsif up; y_lim = find_up_limit coll_list
+					end
+					if rt && @x + @w + @speed.x > x_lim; @x = x_lim - @w; @speed.x = 0
+					elsif lf && @x + @speed.x < x_lim; @x = x_lim; @speed.x = 0
+					elsif dn && @y + @h + @speed.y > y_lim; @y = y_lim - @h; @speed.y = 0
+					elsif up && @y + @speed.y < y_lim; @y = y_lim; @speed.y = 0
+					end
+				else
+					# Diagonal
+					x_aim = @x + @speed.x + (rt ? @w : 0); x_lim_def = x_aim
+					y_aim = @y + @speed.y + (dn ? @h : 0); y_lim_def = y_aim
+					coll_list.each do |c|
+						if c.passable; x_lim = x_aim
+						elsif rt; x_lim = c.x
+						else; x_lim = c.x + c.w
+						end
+						if dn; y_lim = c.y
+						elsif c.passable; y_lim = y_aim
+						else; y_lim = c.y + c.h
+						end
+					
+						if c.passable
+							y_lim_def = y_lim if dn && @y + @h <= y_lim && y_lim < y_lim_def
+						elsif (rt && @x + @w > x_lim) || (lf && @x < x_lim)
+							# Can't limit by x, will limit by y
+							y_lim_def = y_lim if (dn && y_lim < y_lim_def) || (up && y_lim > y_lim_def)
+						elsif (dn && @y + @h > y_lim) || (up && @y < y_lim)
+							# Can't limit by y, will limit by x 
+							x_lim_def = x_lim if (rt && x_lim < x_lim_def) || (lf && x_lim > x_lim_def)
+						else
+							xTime = 1.0 * (x_lim - @x - (@speed.x < 0 ? 0 : @w)) / @speed.x
+							yTime = 1.0 * (y_lim - @y - (@speed.y < 0 ? 0 : @h)) / @speed.y
+							if xTime > yTime
+								# Will limit by x
+								x_lim_def = x_lim if (rt && x_lim < x_lim_def) || (lf && x_lim > x_lim_def)
+							elsif (dn && y_lim < y_lim_def) || (up && y_lim > y_lim_def)
+								y_lim_def = y_lim
+							end
+						end
+					end
+					if x_lim_def != x_aim
+						@speed.x = 0
+						if lf; @x = x_lim_def
+						else; @x = x_lim_def - @w
+						end
+					end
+					if y_lim_def != y_aim
+						@speed.y = 0
+						if up; @y = y_lim_def
+						else; @y = y_lim_def - @h
+						end
+					end
+				end
+			end
+			@x += @speed.x
+			@y += @speed.y
+			
+			ramps.each do |r|
+				r.check_intersection self
+			end
+			check_contact obst, ramps
+		end
+		def check_contact obst, ramps
+			@top = @bottom = @left = @right = nil
+			obst.each do |o|
+				x2 = @x + @w; y2 = @y + @h; x2o = o.x + o.w; y2o = o.y + o.h
+				@right = o if !o.passable && x2.round(6) == o.x.round(6) && y2 > o.y && @y < y2o
+				@left = o if !o.passable && @x.round(6) == x2o.round(6) && y2 > o.y && @y < y2o
+				@bottom = o if y2.round(6) == o.y.round(6) && x2 > o.x && @x < x2o
+				@top = o if !o.passable && @y.round(6) == y2o.round(6) && x2 > o.x && @x < x2o
+			end		
+			if @bottom.nil?
+				ramps.each do |r|
+					if r.contact? self
+						@bottom = r
+						break
+					end
+				end
+			end
+		end
+		def find_right_limit coll_list
+			limit = @x + @w + @speed.x
+			coll_list.each do |c|
+				limit = c.x if !c.passable && c.x < limit
+			end
+			limit
+		end
+		def find_left_limit coll_list
+			limit = @x + @speed.x
+			coll_list.each do |c|
+				limit = c.x + c.w if !c.passable && c.x + c.w > limit
+			end
+			limit
+		end
+		def find_down_limit coll_list
+			limit = @y + @h + @speed.y
+			coll_list.each do |c|
+				limit = c.y if c.y < limit && c.y >= @y + @h
+			end
+			limit
+		end
+		def find_up_limit coll_list
+			limit = @y + @speed.y
+			coll_list.each do |c|
+				limit = c.y + c.h if !c.passable && c.y + c.h > limit
+			end
+			limit
+		end
+	
+		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)
+			@speed.x = 1.0 * x_d * speed / distance
+			@speed.y = 1.0 * y_d * speed / distance
+			
+			x_aim = @x + @speed.x; y_aim = @y + @speed.y
+			passengers = []
+			obstacles.each do |o|
+				if @x + @w > o.x && o.x + o.w > @x
+					foot = o.y + o.h
+					if foot.round(6) == @y.round(6) || @speed.y < 0 && foot < @y && foot > y_aim
+						passengers << o
+					end
+				end
+			end
+		
+			if @speed.x > 0 && x_aim >= aim.x || @speed.x < 0 && x_aim <= aim.x
+				passengers.each do |p| p.x += aim.x - @x end
+				@x = aim.x; @speed.x = 0
+			else
+				passengers.each do |p| p.x += @speed.x end
+				@x = x_aim
+			end
+			if @speed.y > 0 && y_aim >= aim.y || @speed.y < 0 && y_aim <= aim.y
+				@y = aim.y; @speed.y = 0
+			else
+				@y = y_aim
+			end
+		
+			passengers.each do |p| p.y = @y - p.h end
+		end
+	
+		def move_free aim, speed
+			x_d = aim.x - @x; y_d = aim.y - @y
+			distance = Math.sqrt(x_d**2 + y_d**2)
+			@speed.x = 1.0 * x_d * speed / distance
+			@speed.y = 1.0 * y_d * speed / distance
+		
+			if (@speed.x < 0 and @x + @speed.x <= aim.x) or (@speed.x >= 0 and @x + @speed.x >= aim.x)
+				@x = aim.x
+				@speed.x = 0
+			else
+				@x += @speed.x
+			end
+
+			if (@speed.y < 0 and @y + @speed.y <= aim.y) or (@speed.y >= 0 and @y + @speed.y >= aim.y)
+				@y = aim.y
+				@speed.y = 0
+			else
+				@y += @speed.y
+			end
+		end
+	
+		def cycle points, cur_point, speed, obstacles = nil
+			if obstacles
+				move_carrying points[cur_point], speed, obstacles
+			else
+				move_free points[cur_point], speed
+			end
+			if @speed.x == 0 and @speed.y == 0
+				if cur_point == points.length - 1; cur_point = 0
+				else; cur_point += 1; end
+			end
+			cur_point
+		end
+	end
+end

data/lib/minigl/text.rb

@@ -0,0 +1,94 @@
+module AGL
+	class TextHelper
+		def initialize font, line_spacing = 0
+			@font = font
+			@line_spacing = line_spacing
+		end
+	
+		def write_line text, x, y, mode = :left, color = 0xffffffff
+			rel =
+				case mode
+				when :left then 0
+				when :center then 0.5
+				when :right then 1
+				else 0
+				end
+			@font.draw_rel text, x, y, 0, rel, 0, 1, 1, color
+		end
+	
+		def write_breaking text, x, y, width, mode = :left, color = 0xffffffff
+			text.split("\n").each do |p|
+				if mode == :justified
+					y = write_paragraph_justified p, x, y, width, color
+				else
+					rel =
+						case mode
+						when :left then 0
+						when :center then 0.5
+						when :right then 1
+						else 0
+						end
+					y = write_paragraph p, x, y, width, rel, color
+				end
+			end
+		end
+	
+		def write_paragraph text, x, y, width, rel, color
+			line = ""
+			line_width = 0
+			text.split(' ').each do |word|
+				w = @font.text_width word
+				if line_width + w > width
+					@font.draw_rel line.chop, x, y, 0, rel, 0, 1, 1, color
+					line = ""
+					line_width = 0
+					y += @font.height + @line_spacing
+				end
+				line += "#{word} "
+				line_width += @font.text_width "#{word} "
+			end
+			@font.draw_rel line.chop, x, y, 0, rel, 0, 1, 1, color if not line.empty?
+			y + @font.height + @line_spacing
+		end
+	
+		def write_paragraph_justified text, x, y, width, color
+			space_width = @font.text_width " "
+			spaces = [[]]
+			line_index = 0
+			new_x = x
+			words = text.split(' ')
+			words.each do |word|
+				w = @font.text_width word
+				if new_x + w > x + width
+					space = x + width - new_x + space_width
+					index = 0
+					while space > 0
+						spaces[line_index][index] += 1
+						space -= 1
+						index += 1
+						index = 0 if index == spaces[line_index].size - 1
+					end
+				
+					spaces << []
+					line_index += 1
+				
+					new_x = x
+				end
+				new_x += @font.text_width(word) + space_width
+				spaces[line_index] << space_width
+			end
+		
+			index = 0
+			spaces.each do |line|
+				new_x = x
+				line.each do |s|
+					@font.draw words[index], new_x, y, 0, 1, 1, color
+					new_x += @font.text_width(words[index]) + s
+					index += 1
+				end
+				y += @font.height + @line_spacing
+			end
+			y
+		end
+	end
+end

data/lib/minigl.rb

@@ -0,0 +1,4 @@
+require_relative 'minigl/game_object'
+require_relative 'minigl/map'
+require_relative 'minigl/text'
+require_relative 'minigl/forms'

data/test/game_object_tests.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require_relative '../lib/minigl'
+include AGL
+
+class SpriteTest < Test::Unit::TestCase
+	def setup
+		@window = Gosu::Window.new 800, 600, false
+		Game.initialize @window
+	end
+	
+	def test_sprite_position
+		s = Sprite.new 10, 20, :image
+		assert_equal 10, s.x
+		assert_equal 20, s.y
+		s = Sprite.new -100, 200, :image
+		assert_equal -100, s.x
+		assert_equal 200, s.y
+	end
+	
+	def test_sprite_animation
+		s = Sprite.new 10, 20, :image, 3, 1
+		indices = [0, 1, 2]
+		interval = 1
+		3.times { s.animate indices, interval }
+		assert_equal 0, s.img_index
+		5.times { s.animate indices, interval }
+		assert_equal 2, s.img_index
+	end
+end
+
+class GameObjectTest < Test::Unit::TestCase
+	def setup
+		@window = Gosu::Window.new 800, 600, false
+		Game.initialize @window
+	end
+	
+	def test_game_object_attributes
+		o = GameObject.new 10, 20, 3, 1, :image
+		assert_equal 10, o.x
+		assert_equal 20, o.y
+		assert_equal 3, o.w
+		assert_equal 1, o.h
+		assert_equal 0, o.speed.x
+		assert_equal 0, o.speed.y
+		assert_equal 0, o.stored_forces.x
+		assert_equal 0, o.stored_forces.y
+	end
+	
+	def test_game_object_animation
+		o = GameObject.new 10, 20, 3, 1, :image, nil, 3, 1
+		indices = [0, 1, 2]
+		interval = 10
+		5.times { o.animate indices, interval }
+		assert_equal 0, o.img_index
+		o.set_animation 0
+		5.times { o.animate indices, interval }
+		assert_equal 0, o.img_index
+		5.times { o.animate indices, interval }
+		assert_equal 1, o.img_index
+	end
+end

data/test/map_tests.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require_relative '../lib/minigl'
+include AGL
+
+class MapTest < Test::Unit::TestCase
+	def test_map_attributes
+		m = Map.new 16, 16, 300, 200
+		assert_equal 16, m.tile_size.x
+		assert_equal 16, m.tile_size.y
+		assert_equal 300, m.size.x
+		assert_equal 200, m.size.y
+		assert_equal 0, m.cam.x
+		assert_equal 0, m.cam.y
+		m = Map.new 25, 17, 49, 133
+		assert_equal 25, m.tile_size.x
+		assert_equal 17, m.tile_size.y
+		assert_equal 49, m.size.x
+		assert_equal 133, m.size.y
+		assert_equal 0, m.cam.x
+		assert_equal 0, m.cam.y
+	end
+	
+	def test_absolute_size
+		m = Map.new 16, 16, 300, 200
+		v = m.get_absolute_size
+		assert_equal 300 * 16, v.x
+		assert_equal 200 * 16, v.y
+	end
+	
+	def test_center
+		m = Map.new 16, 16, 300, 200
+		v = m.get_center
+		assert_equal 300 * 16 / 2, v.x
+		assert_equal 200 * 16 / 2, v.y
+	end
+	
+	def test_screen_pos
+		m = Map.new 16, 16, 300, 200
+		v = m.get_screen_pos 8, 5
+		assert_equal 8 * 16, v.x
+		assert_equal 5 * 16, v.y
+	end
+	
+	def test_map_pos
+		m = Map.new 16, 16, 300, 200
+		v = m.get_map_pos 410, 300
+		assert_equal 25, v.x
+		assert_equal 18, v.y
+	end
+	
+	def test_in_map
+		m = Map.new 16, 16, 300, 200
+		assert m.is_in_map(Vector.new 30, 20)
+		assert m.is_in_map(Vector.new 299, 199)
+		assert !m.is_in_map(Vector.new 300, 200)
+	end
+end

data/test/movement_tests.rb

@@ -0,0 +1,86 @@
+require 'test/unit'
+require_relative '../lib/minigl'
+include AGL
+
+class MovingObject
+	include Movement
+	def initialize x, y, w, h
+		@x = x; @y = y; @w = w; @h = h
+		@speed = Vector.new 0, 0
+		@min_speed = Vector.new 0.01, 0.01
+		@max_speed = Vector.new 1000, 1000
+		@stored_forces = Vector.new 0, 0
+	end
+end
+
+class MovementTest < Test::Unit::TestCase
+	def setup
+		@window = Gosu::Window.new 800, 600, false
+		Game.initialize @window
+		@obsts = [
+			Block.new(-1, 0, 1, 600, false),
+			Block.new(0, -1, 800, 1, false),
+			Block.new(800, 0, 1, 600, false),
+			Block.new(0, 600, 800, 1, false),
+			Block.new(280, 560, 40, 40, true)
+		]
+		@ramps = [
+			Ramp.new(600, 500, 200, 100, true),
+			Ramp.new(0, 500, 200, 100, false)
+		]
+	end
+	
+	def test_fall
+		o = MovingObject.new 480, 280, 40, 40
+		forces = Vector.new 0, 0
+		1000.times { o.move forces, @obsts, @ramps }
+		assert_equal 480, o.x
+		assert_equal 560, o.y
+		assert_equal 0, o.speed.x
+		assert_equal 0, o.speed.y
+		assert_equal @obsts[3], o.bottom
+	end
+	
+	def test_multiple_collision
+		o = MovingObject.new 750, 10, 40, 40
+		forces = Vector.new 50, -60
+		o.move forces, @obsts, @ramps
+		assert_equal 760, o.x
+		assert_equal 0, o.y
+		assert_equal 0, o.speed.x
+		assert_equal 0, o.speed.y
+		assert_equal @obsts[1], o.top
+		assert_equal @obsts[2], o.right
+	end
+	
+	def test_passable
+		o = MovingObject.new 480, 560, 40, 40
+		forces = Vector.new -250, 0
+		o.move forces, @obsts, @ramps
+		assert(o.x < @obsts[4].x)
+	end
+	
+	def test_left_ramp
+		o = MovingObject.new 380, 560, 40, 40
+		forces = Vector.new 10, 0
+		1000.times { o.move forces, @obsts, @ramps }
+		assert_equal 760, o.x
+		assert_equal 460, o.y
+		assert_equal 0, o.speed.x
+		assert_equal 0, o.speed.y
+		assert_equal @obsts[2], o.right
+		assert_equal @ramps[0], o.bottom
+	end
+	
+	def test_right_ramp
+		o = MovingObject.new 380, 560, 40, 40
+		forces = Vector.new -10, 0
+		1000.times { o.move forces, @obsts, @ramps }
+		assert_equal 0, o.x
+		assert_equal 460, o.y
+		assert_equal 0, o.speed.x
+		assert_equal 0, o.speed.y
+		assert_equal @obsts[0], o.left
+		assert_equal @ramps[1], o.bottom
+	end
+end