rmaze 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8de1761ea1c434699b107bfd7ac8f67066ccbb72
+  data.tar.gz: 5a00adebfa0161e2bc9da4c708d35080f687e385
+SHA512:
+  metadata.gz: ee50ce8778253e1915c1c4591ebb4e2ed6c08a68ef834cfd77116b88d68a18533c7f29ebe57a7f59b2b3b6434d98593d49fa3f6d1bc188723d71f35dfa9786cf
+  data.tar.gz: f225f4e02d3955852991b646319cbb9dcee0e713df7f55c544bd293a8325b0366805fa055799396c0fc18a7b87c88ffd217db3189fe0f7296ed1943b18f1f186

data/.gitignore

@@ -0,0 +1,2 @@
+*.swp
+coverage/

data/.rspec

@@ -0,0 +1 @@
+-c -r ./spec/spec_helper.rb -r ./lib/rmaze.rb

data/.ruby-gemset

@@ -0,0 +1 @@
+maze

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.3

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'OptionParser', '~> 0.5.1'
+gem 'rubytree', '~> 0.9.4'
+
+group :test do
+	gem 'rspec', '~> 3.1.0'
+	gem 'simplecov', :require => false
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    OptionParser (0.5.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.1)
+    multi_json (1.10.1)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.5)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.2)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.1)
+    rubytree (0.9.4)
+      json (~> 1.8)
+      structured_warnings (~> 0.1)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    structured_warnings (0.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  OptionParser (~> 0.5.1)
+  rspec (~> 3.1.0)
+  rubytree (~> 0.9.4)
+  simplecov

data/README.md

@@ -0,0 +1,4 @@
+Maze
+====
+
+Ruby library for maze generation

data/lib/maze/maze.rb

@@ -0,0 +1,76 @@
+require 'maze/maze_cell'
+
+class Maze
+	protected
+	attr_reader :matrix
+
+	def initialize_matrix
+		@matrix = []
+		(0...@height_full).each do
+			@matrix << [0]*@width_full
+		end
+	end
+
+	def make_value(value = 0)
+		(0...@height_full).each do |i|
+			(0...@width_full).each do |j|
+				@matrix[i][j] = value
+			end
+		end
+	end
+
+	def make_unconnected
+		make_value(1)
+		(0...@width).each do |x|
+			(0...@height).each do |y|
+				i, j = xy_to_ij(x, y)
+				@matrix[i][j] = 0
+			end
+		end
+	end
+
+	public
+	attr_reader :mirrored, :width, :height, :width_full, :height_full
+
+	def initialize(width, height)
+		@mirrored = false
+		@height, @width = height.to_i, width.to_i
+		@height_full, @width_full = (1 + 2*@height), (1 + 2*@width)
+		initialize_matrix
+		@hash = "#{@width}#{@height}".to_i # optimized pre-computed hash
+	end
+
+	def debug
+		@matrix.each do |row|
+			puts row.join(' ').gsub(/0/, ' ').gsub(/1/, '#').gsub(/2/, 'X')
+		end
+		self
+	end
+
+	def value(i, j)
+		@matrix[i][j]
+	end
+
+	def cell(x, y)
+		MazeCell.new(self, x, y)
+	end
+
+	def xy_to_ij(x, y)
+		x, y = x % @width, y % @height if @mirrored
+		i = 1 + (2 * y)
+		j = 1 + (2 * x)
+		[i, j]
+	end
+
+	def generate
+		self
+	end
+
+	def hash
+		@hash
+	end
+
+	def inspect
+		"#<#{self.class}: @width=#{@width}, @height=#{@height}>"
+	end
+end

data/lib/maze/maze_btrace.rb

@@ -0,0 +1,57 @@
+require 'maze/maze'
+
+class MazeBTrace < Maze
+	protected
+	def initialize_matrix
+		super
+		make_unconnected
+	end
+
+	public
+	def initialize(width, height)
+		super(width, height)
+	end
+
+	def between_cells(cell_a, cell_b)
+		i_a, j_a = xy_to_ij(cell_a.x, cell_a.y)
+		i_b, j_b = xy_to_ij(cell_b.x, cell_b.y)
+		[(i_a + i_b).abs / 2, (j_a + j_b).abs / 2]
+	end
+
+	def generate
+		super
+		stack = []
+		visited_cells = []
+		all_index_cells = []
+		current_cell = cell(rand(@width), rand(@height))
+		visited_cells.push current_cell
+		(0...@width).each do |x|
+			(0...@height).each do |y|
+				all_index_cells << [x, y]
+			end
+		end
+		while visited_cells.size != @width * @height
+			neighbours = current_cell.neighbours
+			visited_cells.push current_cell
+			unvisited_neighbours = (neighbours - visited_cells)
+			if !unvisited_neighbours.empty?
+				stack.push current_cell
+				random_neighbour = unvisited_neighbours.shuffle.shift
+				i, j = xy_to_ij(random_neighbour.x, random_neighbour.y)
+				inner_i, inner_j = between_cells(current_cell, random_neighbour)
+				@matrix[inner_i][inner_j] = 0
+				current_cell = random_neighbour
+				visited_cells.push current_cell
+			elsif !stack.empty?
+				current_cell = stack.pop
+			else
+				unvisited_index_cells = all_index_cells - visited_cells.map { |c| [c.x, c.y] }
+				unvisited_index_cell = unvisited_index_cells.shuffle.shift
+				current_cell = cell(unvisited_index_cell[0], unvisited_index_cell[0])
+				visited_cells.push current_cell
+			end
+			visited_cells.uniq!
+		end
+		self
+	end
+end

data/lib/maze/maze_cell.rb

@@ -0,0 +1,94 @@
+class MazeCell
+	attr_reader :maze, :x, :y
+
+	def initialize(maze, x, y)
+		@maze = maze
+		@x, @y = x.to_i, y.to_i
+		@x, @y = x % @maze.width, y % @maze.height if @maze.mirrored
+		@hash = "#{@maze.hash}#{@x}#{@y}".to_i
+	end
+
+	def debug
+		i, j = @maze.xy_to_ij(@x, @y)
+		puts "  #{@maze.value(i - 1, j)}  "
+		puts "#{@maze.value(i, j - 1)} #{@maze.value(i, j)} #{@maze.value(i, j + 1)}"
+		puts "  #{@maze.value(i + 1, j)}  "
+	end
+
+	def left
+		MazeCell.new(@maze, @x - 1, @y) if @maze.mirrored || @x > 0
+	end
+
+	def up
+		MazeCell.new(@maze, @x, @y - 1) if @maze.mirrored || @y > 0
+	end
+
+	def right
+		MazeCell.new(@maze, @x + 1, @y) if @maze.mirrored || @x < (@maze.width - 1)
+	end
+
+	def down
+		MazeCell.new(@maze, @x, @y + 1) if @maze.mirrored || @y < (@maze.height - 1)
+	end
+
+	def has_wall_left?
+		i, j = @maze.xy_to_ij(@x, @y)
+		@maze.value(i, j - 1) != 0
+	end
+
+	def has_wall_up?
+		i, j = @maze.xy_to_ij(@x, @y)
+		@maze.value(i - 1, j) != 0
+	end
+
+	def has_wall_right?
+		i, j = @maze.xy_to_ij(@x, @y)
+		@maze.value(i, j + 1) != 0
+	end
+
+	def has_wall_down?
+		i, j = @maze.xy_to_ij(@x, @y)
+		@maze.value(i + 1, j) != 0
+	end
+
+	def connected?
+		!(has_wall_left? && has_wall_up? && has_wall_right? && has_wall_down?)
+	end
+
+	def neighbours
+		[left, up, right, down].compact
+	end
+
+	def connected_neighbours
+		neighbours = []
+		neighbours << left unless has_wall_left?
+		neighbours << up unless has_wall_up?
+		neighbours << right unless has_wall_right?
+		neighbours << down unless has_wall_down?
+		neighbours
+	end
+
+	def hash
+		@hash
+	end
+
+	def eql?(object)
+		if (object.class == self.class)
+			 @x == object.x && @y == object.y && @maze == object.maze
+		elsif
+			super(object)
+		end
+	end
+
+	def ==(object)
+		self.eql? object
+	end
+
+	def !=(object)
+		!(self.eql? object)
+	end
+
+	def inspect
+		"#<#{self.class}: @maze=#{@maze.inspect}, @x=#{@x}, @y=#{@y}>"
+	end
+end

data/lib/rmaze.rb

@@ -0,0 +1,7 @@
+expand_path = File.expand_path('..', __FILE__)
+
+$LOAD_PATH.unshift expand_path
+
+Dir.glob(File.join(expand_path, "**/*.rb")) do |file|
+	require file
+end

data/maze_gen.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require './lib/rmaze.rb'
+require 'optparse'
+
+options = {
+	:width => 10,
+	:height => 10,
+	:algorithm => :backtrace
+}
+OptionParser.new do |opts|
+	opts.banner = "Usage: maze_gen.rb [options]"
+
+	opts.separator ""
+	opts.separator "Basic options:"
+	opts.on("-w", "--width width", "Specify the maze width (default: #{options[:width]})") do |width|
+		options[:width] = width
+	end
+	opts.on("-h", "--height height", "Specify the maze height (default: #{options[:height]})") do |height|
+		options[:height] = height
+	end
+
+	opts.separator ""
+	opts.separator "Algorithms:"
+	opts.on("-b", "--backtrace", "Choose backtrace algorithm (default)") do |bt|
+		options[:algorithm] = bt ? :backtrace : nil
+	end
+end.parse!
+
+maze = nil
+case options[:algorithm]
+when :backtrace
+	maze = MazeBTrace.new(options[:width], options[:height])
+else
+	$stderr.puts "Error: the algorithm must be set."
+	exit(-1)
+end
+
+maze.generate
+maze.debug

data/rmaze.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+	s.name        = 'rmaze'
+	s.version     = '1.0.0'
+	s.date        = '2014-10-01'
+	s.licenses    = ["MIT"]
+	s.platform    = Gem::Platform::RUBY
+	s.summary     = "RMaze"
+	s.description = "Ruby library for maze generation"
+	s.authors     = ["Pedro Lira"]
+	s.email       = 'pedrohml@gmail.com'
+	s.files         = `git ls-files`.split("\n")
+	s.test_files    = `git ls-files -- spec/*`.split("\n")
+	s.homepage    = 'https://github.com/pedrohml/rmaze'
+	s.require_paths = ["lib"]
+end

data/spec/maze/maze_btrace_spec.rb

@@ -0,0 +1,11 @@
+describe MazeBTrace do
+	before do
+		@width = rand(10) + 15
+		@height = rand(10) + 15
+		@maze = MazeBTrace.new(@width, @height)
+	end
+
+	it '#generate' do
+		expect { @maze.generate }.not_to raise_error
+	end
+end

data/spec/maze/maze_cell_spec.rb

@@ -0,0 +1,95 @@
+describe MazeCell do
+	before do
+		@width = 4
+		@height = 4
+		@maze = MazeBTrace.new(@width, @height)
+		@maze_zero = Maze.new(@width, @height)
+	end
+
+	it '#initialize' do
+		maze_cell = MazeCell.new(@maze, 1, 0)
+		expect(maze_cell.maze).to eq(@maze)
+		expect(maze_cell.x).to eq(1)
+		expect(maze_cell.y).to eq(0)
+	end
+
+	it 'gets directions' do
+		maze_cell = @maze.cell(0, 0)
+		expect(maze_cell.left).to be_nil
+		expect(maze_cell.up).to be_nil
+		expect(maze_cell.right).to eq(@maze.cell(1, 0))
+		expect(maze_cell.down).to eq(@maze.cell(0, 1))
+	end
+
+	it 'checks wall' do
+		maze_cell = @maze.cell(0, 0)
+		expect(maze_cell).to have_wall_left
+		expect(maze_cell).to have_wall_up
+		expect(maze_cell).to have_wall_right
+		expect(maze_cell).to have_wall_down
+		maze_zero_cell = @maze_zero.cell(1, 1)
+		expect(maze_zero_cell).not_to have_wall_left
+		expect(maze_zero_cell).not_to have_wall_up
+		expect(maze_zero_cell).not_to have_wall_right
+		expect(maze_zero_cell).not_to have_wall_down
+	end
+
+	it '#connected?' do
+		expect(@maze.cell(0, 0)).not_to be_connected
+		expect(@maze_zero.cell(1, 0)).to be_connected
+	end
+
+	it '#connected_neighbours' do
+		expect(@maze.cell(0, 0).connected_neighbours).to be_empty
+		expect(@maze_zero.cell(1, 1).connected_neighbours.size).to eq(4)
+	end
+
+	it '#neighbours' do
+		maze_cell = @maze.cell(0, 0)
+		neighbours = maze_cell.neighbours
+		expect(neighbours.size).to eq(2)
+		expect(neighbours).to include(@maze.cell(1, 0))
+		expect(neighbours).to include(@maze.cell(0, 1))
+		expect(neighbours).not_to include(@maze.cell(0, 0))
+	end
+
+	it '#hash' do
+		allow_any_instance_of(MazeCell).to receive(:eql?).and_return(true) # remove elements only based on hash
+		cells = [@maze.cell(0, 0), @maze.cell(1, 0), @maze.cell(0, 1)]
+		cells -= [@maze.cell(0, 0)]
+		expect(cells).to contain_exactly(@maze.cell(1, 0), @maze.cell(0, 1))
+	end
+
+	it '#eql?' do
+		maze_cell = @maze.cell(0, 0)
+		expect(maze_cell).to eql(maze_cell)
+		expect(maze_cell).to eql(@maze.cell(0, 0))
+		expect(maze_cell).not_to eql(@maze.cell(1, 0))
+		expect(maze_cell).not_to eql(nil)
+	end
+
+	it '#==' do
+		maze_cell = @maze.cell(0, 0)
+		expect(maze_cell).to eq(maze_cell)
+		expect(maze_cell).to eq(@maze.cell(0, 0))
+		expect(maze_cell).not_to eq(@maze.cell(1, 0))
+		expect(maze_cell).not_to eq(nil)
+	end
+
+	it '#!=' do
+		maze_cell = @maze.cell(0, 0)
+		expect(maze_cell != @maze.cell(1, 0)).to be_truthy
+		expect(maze_cell != nil).to be_truthy
+	end
+
+	it '#debug' do
+		allow($stdout).to receive(:puts).exactly(3).times
+		maze_cell = @maze.cell(0, 0)
+		maze_cell.debug
+	end
+
+	it '#inspect' do
+		maze_cell = @maze.cell(1, 0)
+		expect(maze_cell.inspect).to eq("#<MazeCell: @maze=#{@maze.inspect}, @x=#{1}, @y=#{0}>")
+	end
+end

data/spec/maze/maze_spec.rb

@@ -0,0 +1,47 @@
+describe Maze do
+	before do
+		@width = rand(10) + 15
+		@height = rand(10) + 15
+		@maze = Maze.new(@width, @height)
+	end
+
+	it '#initialize' do
+		expect(@maze.width).to eq(@width)
+		expect(@maze.height).to eq(@height)
+	end
+
+	it '#value' do
+		expect(@maze.value(0, 0)).to eq(0)
+	end
+
+	it '#cell' do
+		cell = @maze.cell(3, 8)
+		expect(cell).to be_a_kind_of(MazeCell)
+		expect(cell.maze).to eq(@maze)
+		expect(cell.x).to eq(3)
+		expect(cell.y).to eq(8)
+	end
+
+	it '#xy_to_ij' do
+		x, y = 0, 0
+		i, j = @maze.xy_to_ij(x, y)
+		expect([i, j]).to eq([1, 1])
+	end
+
+	it '#generate' do
+		expect(@maze.generate).to eq(@maze)
+	end
+
+	it '#hash' do
+		expect(@maze.hash).to eq("#{@width}#{@height}".to_i)
+	end
+
+	it '#inspect' do
+		expect(@maze.inspect).to eq("#<Maze: @width=#{@width}, @height=#{@height}>")
+	end
+
+	it '#debug' do
+		allow($stdout).to receive(:puts).exactly(@maze.height_full).times
+		@maze.debug
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+
+SimpleCov.start

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: rmaze
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Pedro Lira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-01 00:00:00.000000000 Z
+dependencies: []
+description: Ruby library for maze generation
+email: pedrohml@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/maze/maze.rb
+- lib/maze/maze_btrace.rb
+- lib/maze/maze_cell.rb
+- lib/rmaze.rb
+- maze_gen.rb
+- rmaze.gemspec
+- spec/maze/maze_btrace_spec.rb
+- spec/maze/maze_cell_spec.rb
+- spec/maze/maze_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/pedrohml/rmaze
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: RMaze
+test_files:
+- spec/maze/maze_btrace_spec.rb
+- spec/maze/maze_cell_spec.rb
+- spec/maze/maze_spec.rb
+- spec/spec_helper.rb