rmaze 1.5.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85febacd983d96080346ecd776ce57a069bf3298
-  data.tar.gz: 3fc99125e1fe8afd4c5e01d945b1f0548e9e39e3
+  metadata.gz: e9e0430fb1d38141827770a72ae3438a451ed1ca
+  data.tar.gz: 15a61f5a73f128132ed27b0a2f08b2bfaa5bb3e4
 SHA512:
-  metadata.gz: 873a51c14c421519625a731e828a571ad8cbf0f375f09ced7d5e7cd31bc34d811788d16d886abad3319b6de1cf6ad21b6dd95232d67ee6efd3fc3eaf27a4609f
-  data.tar.gz: 291daa9e8d1f598c013de04306988d83a3f10e280dec2b92ecfb7c40be682ea45193611b14f2ae486afff75d46d0ae2104e7f87b14b8725b7a71446f09f4c195
+  metadata.gz: a5a3263729d2f09ded3176dbef2531779c8ebb1f7f3ab38342b473dabd4a94142c1ab7709276c264788eca2f201da5a39728bd4720186fd5da88c096521bfc8a
+  data.tar.gz: 324f2f23e46d31728e3e4e77f71f31fd958aea40b4bf056b348a33b42c9f9213f490c3e0b3fe25bc68bd0d3ad19aacc8a79820fa26cb105162180f4ea106b03d

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.3
+ruby-2.2.1

data/Gemfile

@@ -6,5 +6,5 @@ gem 'rake', '~> 10.1.0'
 
 group :test do
 	gem 'rspec', '~> 3.1.0'
-	gem 'simplecov', :require => false
+	gem 'coveralls', require: false
 end

data/Gemfile.lock

@@ -2,11 +2,27 @@ GEM
   remote: https://rubygems.org/
   specs:
     OptionParser (0.5.1)
+    coveralls (0.8.10)
+      json (~> 1.8)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.11.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+      tins (~> 1.6.0)
     diff-lcs (1.2.5)
     docile (1.1.5)
+    domain_name (0.5.25)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
     json (1.8.1)
-    multi_json (1.10.1)
+    mime-types (2.99)
+    netrc (0.11.0)
     rake (10.1.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
     rspec (3.1.0)
       rspec-core (~> 3.1.0)
       rspec-expectations (~> 3.1.0)
@@ -22,22 +38,29 @@ GEM
     rubytree (0.9.4)
       json (~> 1.8)
       structured_warnings (~> 0.1)
-    simplecov (0.9.1)
+    simplecov (0.11.1)
       docile (~> 1.1.0)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.8.0)
-    simplecov-html (0.8.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
     structured_warnings (0.1.4)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.6.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   OptionParser (~> 0.5.1)
+  coveralls
   rake (~> 10.1.0)
   rspec (~> 3.1.0)
   rubytree (~> 0.9.4)
-  simplecov
 
 BUNDLED WITH
    1.11.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Pedro Henrique Marques Lira
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,17 +1,23 @@
 # RMaze
-Ruby library and tool for 2D maze generation
+Ruby library for multidimensional maze generation
 
-[![Build Status](http://travis-ci.org/pedrohml/rmaze.svg?branch=master)](http://travis-ci.org/pedrohml/rmaze)
+[![Gem Version](https://img.shields.io/gem/v/rmaze.svg)](https://rubygems.org/gems/rmaze)
+[![Build Status](https://img.shields.io/travis/pedrohml/rmaze/master.svg)](http://travis-ci.org/pedrohml/rmaze)
+[![Coverage Status](https://img.shields.io/coveralls/pedrohml/rmaze.svg)](https://coveralls.io/github/pedrohml/rmaze)
 [![Security](http://hakiri.io/github/pedrohml/rmaze/master.svg)](https://hakiri.io/github/pedrohml/rmaze/master)
+[![License](https://img.shields.io/github/license/pedrohml/rmaze.svg)](https://github.com/pedrohml/rmaze/blob/master/LICENSE.txt)
 
 #### Description
-This simple library/tool generates 2D mazes with customizable dimensions.
+This library generates multidimensional mazes.
+
+- What the purpose ? Mainly, games.
+- What do I want Nth-d mazes for ? I do not know yet.
 
 #### Tool usage
-The **rmaze** is in initial version and its simple to use
+The tool **rmaze** is in initial version and only supports bidimensional mazes.
 
 ```
-Usage: rmaze.rb [options]
+Usage: rmaze [options]
 
 Basic options:
     -w, --width width                Specify the maze width (default: 10)

data/bin/rmaze

@@ -27,14 +27,18 @@ OptionParser.new do |opts|
 	end
 end.parse!
 
-maze = nil
+maze = Maze.new options[:width], options[:height]
+maze.set_raw_value_all 1
+
 case options[:algorithm]
 when :backtrace
-	maze = MazeBTrace.new(options[:width], options[:height])
+	backtrace = Backtrace.new maze
+    backtrace.generate
 else
 	$stderr.puts "Error: the algorithm must be set."
 	exit(-1)
 end
 
-maze.generate
-maze.print
+maze.matrix.each_with_index do |row, index|
+    puts row.map(&:to_s).join(' ').gsub('0', ' ').gsub('1', '#')
+end

data/lib/algorithm/backtrace.rb

@@ -0,0 +1,46 @@
+require 'maze/maze'
+
+class Backtrace
+    attr_reader :maze
+
+	def initialize(maze)
+        @maze = maze
+	end
+
+	def generate
+		stack = []
+		visited_cells = []
+		all_cells = []
+        @maze.set_raw_value_all 1
+        all_cells = @maze.cells
+
+        all_cells.each do |cell|
+            @maze.set_value *cell.coords.clone.push(0)
+        end
+
+		current_cell = @maze.cell *@maze.dimensions.map { |d| rand(d) }
+		visited_cells.push current_cell
+
+		while visited_cells.size != @maze.total_cells
+			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
+                @maze.connect_cells current_cell, random_neighbour
+				current_cell = random_neighbour
+				visited_cells.push current_cell
+			elsif !stack.empty?
+				current_cell = stack.pop
+			else
+				unvisited_index_cells = all_cells - visited_cells
+				unvisited_index_cell = unvisited_index_cells.shuffle.shift
+				current_cell = unvisited_index_cell
+				visited_cells.push current_cell
+			end
+			visited_cells.uniq!
+		end
+		@maze
+	end
+end

data/lib/game/game.rb

@@ -7,9 +7,9 @@ class Game
 
 	def select_goal_cell(dificulty)
 		dificulty = dificulty.to_sym
-		solver = TreeSolver.new(@maze)
-		start_x, start_y = 0, 0
-		paths = solver.paths(start_x, start_y)
+		solver = TreeSolver.new @maze
+		start_coords = [0]*@maze.dimensions.length
+		paths = solver.paths *start_coords
 		leafs = {}
 		paths.each_leaf do |leaf|
 			leafs[leaf.node_depth] = leaf
@@ -17,21 +17,23 @@ class Game
 		depths = leafs.keys.sort
 		case dificulty
 		when :easy
-			selected_depth = depths[(depths.size*0.25).ceil]
+			selected_depth = depths[(depths.size/4).ceil]
 		when :medium
-			selected_depth = depths[(depths.size*0.5).ceil]
+			selected_depth = depths[(depths.size/2).ceil]
 		when :hard
 			selected_depth = depths.last
 		else
-			selected_depth = depths[rand((depths.size/2.0).ceil) + (depths.size/2.0).ceil]
+			selected_depth = depths[(depths.size/2.0).floor + rand((depths.size/2.0).round)]
 		end
 		leafs[selected_depth].content
 	end
 
 	def generate_goal(dificulty)
-		selected_cell = select_goal_cell(dificulty)
-		i, j = @maze.xy_to_ij(selected_cell.x, selected_cell.y)
-		@maze.matrix[i][j] = 2
+		selected_cell = select_goal_cell dificulty
+		indices = @maze.coords_to_indices *selected_cell.coords
+        params = indices.clone
+        params.push 2
+		@maze.set_raw_value *params
 		@maze
 	end
 end

data/lib/maze/maze.rb

@@ -2,73 +2,140 @@ require 'maze/maze_cell'
 
 class Maze
 	protected
-	def initialize_matrix
-		@matrix = []
-		(0...@height_full).each do
-			@matrix << [0]*@width_full
+	def allocate(value = 0)
+		axis = []
+		axis_before = []
+		@raw_dimensions.reverse.each_with_index do |dr, dr_index|
+			axis = []
+			if dr_index == 0
+				axis = [value] * dr
+			else
+				(0...dr).each do
+					axis << axis_before.clone
+				end
+			end
+			axis_before = axis
 		end
+		@matrix = axis
 	end
 
-	def make_value(value = 0)
-		(0...@height_full).each do |i|
-			(0...@width_full).each do |j|
-				@matrix[i][j] = value
-			end
-		end
+    def set_between_cells(cell_a, cell_b, value)
+        indices = between_cells cell_a, cell_b
+        params = indices.clone
+        params.push value
+        set_raw_value *params
+        indices
+    end
+
+    def evaluate_indices(dim_sizes)
+        matrix_aux = @matrix
+        indices = []
+        stack = []
+        begin
+            if not stack.empty? and stack.last >= dim_sizes[stack.length - 1]
+                stack.pop
+                stack[-1] += 1 if not stack.empty?
+            elsif stack.length < dim_sizes.length - 1
+                matrix_before = matrix_aux
+                stack.push 0
+                matrix_aux = matrix_aux[stack.last]
+            else
+                (0...dim_sizes.last).each { |d| indices.push(stack + [d]) }
+                stack[-1] += 1
+            end
+        end until stack.empty?
+        indices
+    end
+
+	public
+	attr_reader :dimensions, :width_full, :height_full, :matrix
+
+	def initialize(*dimensions)
+		@dimensions = dimensions.map { |d| d.to_i }.freeze
+		@raw_dimensions = @dimensions.map { |d| 1 + 2*d }.freeze
+		allocate 0
+		@hash = @dimensions.reduce(""){ |accum, d| "#{accum}#{d}" }.to_i
 	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
+    def total_cells
+        dimensions.reduce(1) { |accum, d| accum*d }
+    end
+
+    def total_raw
+        dimensions.reduce(1) { |accum, d| accum*(1 + 2*d) }
+    end
+
+	def coords_to_indices(*coords)
+		coords.map { |c| 1 + 2 * c }
 	end
 
-	public
-	attr_reader :mirrored, :width, :height, :width_full, :height_full, :matrix
-
-	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
+	def get_raw_value(*indices)
+		matrix_aux = @matrix
+		indices.each_with_index do |c|
+			matrix_aux = matrix_aux[c]
+		end
+		matrix_aux
 	end
 
-	def print
-		@matrix.each do |row|
-			puts row.join(' ').gsub(/0/, ' ').gsub(/1/, '#').gsub(/2/, 'X')
+	def set_raw_value(*indices)
+		matrix_aux = @matrix
+		indices = indices.clone
+		value = indices.pop
+		indices.each_with_index do |c, c_index|
+			matrix_aux[c] = value if c_index == indices.length - 1
+			matrix_aux = matrix_aux[c]
 		end
-		self
+		matrix_aux
 	end
 
-	def value(i, j)
-		@matrix[i][j]
+	def set_raw_value_all(value)
+		allocate value
 	end
 
-	def cell(x, y)
-		MazeCell.new(self, x, y)
+	def get_value(*coords)
+		get_raw_value *self.coords_to_indices(*coords)
 	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]
+	def set_value(*coords)
+        coords = coords.clone
+		value = coords.pop
+		set_raw_value *self.coords_to_indices(*coords).push(value)
 	end
 
-	def generate
-		self
+	def cell(*coords)
+		params = coords.clone
+		params.unshift self
+		MazeCell.new *params
 	end
 
+    def cells
+        evaluate_indices(@dimensions).map { |coord| cell *coord }
+    end
+
+	def between_cells(cell_a, cell_b)
+		indices_a = coords_to_indices *cell_a.coords
+		indices_b = coords_to_indices *cell_b.coords
+        indices_a.zip(indices_b).map { |pair| (pair[0] + pair[1]) / 2.0 }
+	end
+
+    def connect_cells(cell_a, cell_b)
+        set_between_cells cell_a, cell_b, 0
+    end
+
+    def disconnect_cells(cell_a, cell_b)
+        set_between_cells cell_a, cell_b, 1
+    end
+
 	def hash
 		@hash
 	end
 
 	def inspect
-		"#<#{self.class}: @width=#{@width}, @height=#{@height}>"
+		if not @inspect
+			d_index = 0
+			dimension_list = @dimensions.map { |d| "@d#{d_index+=1}=#{d}" }
+			@inspect = "#<#{self.class}: #{dimension_list.join(', ')}>"
+		end
+		@inspect
 	end
 end

data/lib/maze/maze_cell.rb

@@ -1,99 +1,101 @@
 class MazeCell
-	attr_reader :maze, :x, :y
+	attr_reader :maze, :coords
 
-	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
+	def initialize(*params)
+		params = params.clone
+		@maze = params.shift
+		@coords = params.map { |c| c.to_i }
+		@hash = "#{@maze.hash}#{ @coords.reduce(""){ |accum, c| "#{accum}#{c}" }.to_i }".to_i
 	end
 
-	def print
-		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)
+	def value
+		@maze.get_value *@coords
 	end
 
-	def has_wall_left?
-		i, j = @maze.xy_to_ij(@x, @y)
-		@maze.value(i, j - 1) != 0
+	def backward(dimension_index)
+		coords = @coords.clone
+		coords[dimension_index] -= 1
+		params = coords.clone
+		params.unshift @maze
+		MazeCell.new *params if @coords[dimension_index] > 0
 	end
 
-	def has_wall_up?
-		i, j = @maze.xy_to_ij(@x, @y)
-		@maze.value(i - 1, j) != 0
+	def forward(dimension_index)
+		coords = @coords.clone
+		coords[dimension_index] += 1
+		params = coords.clone
+		params.unshift @maze
+		MazeCell.new *params if @coords[dimension_index] < (@maze.dimensions[dimension_index] - 1)
 	end
 
-	def has_wall_right?
-		i, j = @maze.xy_to_ij(@x, @y)
-		@maze.value(i, j + 1) != 0
+	def has_wall_forward(dimension_index)
+		indices = @maze.coords_to_indices *@coords
+		indices[dimension_index] += 1
+		@coords[dimension_index] >= @maze.dimensions[dimension_index] - 1 or @maze.get_raw_value(*indices) == 1
 	end
 
-	def has_wall_down?
-		i, j = @maze.xy_to_ij(@x, @y)
-		@maze.value(i + 1, j) != 0
+	def has_wall_backward(dimension_index)
+		indices = @maze.coords_to_indices *@coords
+		indices[dimension_index] -= 1
+		@coords[dimension_index] <= 0 or @maze.get_raw_value(*indices) == 1
 	end
 
 	def connected?
-		!(has_wall_left? && has_wall_up? && has_wall_right? && has_wall_down?)
+		has_wall = true
+		(0...@maze.dimensions.length).each do |d|
+			has_wall = has_wall && has_wall_forward(d) && has_wall_backward(d)
+			break unless has_wall
+		end
+		not has_wall
 	end
 
 	def neighbours
-		[left, up, right, down].compact
+		(0...@maze.dimensions.length).map { |d| [forward(d), backward(d)] }.flatten.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?
+		(0...@maze.dimensions.length).each do |d|
+			neighbours << forward(d) unless has_wall_forward(d)
+			neighbours << backward(d) unless has_wall_backward(d)
+		end
 		neighbours
 	end
 	
-	def value
-		i, j = xy_to_ij(@x, @y)
-		@maze.value(i, j)
-	end
-
 	def hash
 		@hash
 	end
 
 	def eql?(object)
 		if (object.class == self.class)
-			 @x == object.x && @y == object.y && @maze == object.maze
+			eq = (@maze == object.maze)
+			@coords.each_with_index do |c, c_idx|
+				eq = eq && c == object[c_idx]
+			end
+			eq
 		elsif
 			super(object)
 		end
 	end
 
+	def [](dimension_index)
+		@coords[dimension_index]
+	end
+
 	def ==(object)
 		self.eql? object
 	end
 
 	def !=(object)
-		!(self.eql? object)
+		not self.eql? object
 	end
 
 	def inspect
-		"#<#{self.class}: @maze=#{@maze.inspect}, @x=#{@x}, @y=#{@y}>"
+		unless @inspect
+			c_index = 0
+			coord_list = @coords.map { |c| "@c#{c_index+=1}=#{c}" }
+			@inspect = "#<#{self.class}: @maze=#{@maze.inspect}, #{coord_list.join(', ')}>"
+		end
+		@inspect
 	end
 end

data/lib/solver/tree_solver.rb

@@ -7,13 +7,13 @@ class TreeSolver
 		@maze = maze
 	end
 
-	def paths(start_x, start_y)
-		current_cell = @maze.cell(start_x, start_y)
-		root_node = current_node = Tree::TreeNode.new("#{current_cell.x},#{current_cell.y}", current_cell)
+	def paths(*coords)
+		current_cell = @maze.cell *coords
+		root_node = current_node = Tree::TreeNode.new(current_cell.coords.map(&:to_s).join(','), current_cell)
 		visited_cells = [current_cell]
 		stack_node = []
 		stack_cell = []
-		while visited_cells.size != @maze.width * @maze.height
+		while visited_cells.size != @maze.total_cells
 			neighbours = current_cell.connected_neighbours
 			unvisited_neighbours = neighbours - visited_cells
 			if unvisited_neighbours.size == 0
@@ -25,7 +25,7 @@ class TreeSolver
 				stack_node += [current_node]*unvisited_neighbours.size
 			end
 			visited_cells << current_cell
-			new_node = Tree::TreeNode.new("#{current_cell.x},#{current_cell.y}", current_cell)
+			new_node = Tree::TreeNode.new(current_cell.coords.map(&:to_s).join(','), current_cell)
 			current_node << new_node 
 			current_node = new_node
 		end

data/rmaze.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name        = 'rmaze'
-	s.version     = '1.5.0'
+	s.version     = '2.0.0'
 	s.date        = '2014-10-01'
 	s.licenses    = ["MIT"]
 	s.platform    = Gem::Platform::RUBY

data/spec/algorithm/backtrace_spec.rb

@@ -0,0 +1,22 @@
+describe Backtrace do
+	it '#initialize' do
+		maze = Maze.new(rand(10) + 15, rand(10) + 15)
+        backtrace = Backtrace.new maze
+        expect(backtrace.maze).to eq(maze)
+	end
+
+    it '#generate 2d' do
+		maze = Maze.new(rand(10) + 15, rand(10) + 15)
+        backtrace = Backtrace.new maze
+        backtrace.generate
+        expect(maze.cells.map { |cell| cell.connected? }).to be_all
+    end
+
+    it '#generate Nd' do
+		dimensions = ([nil]*(rand(4)+2)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+        backtrace = Backtrace.new maze
+        backtrace.generate
+        expect(maze.cells.map { |cell| cell.connected? }).to be_all
+    end
+end

data/spec/game/game_spec.rb

@@ -1,13 +1,14 @@
 describe Game do
 	before do
-		@maze = MazeBTrace.new(8, 8)
-		@maze.generate
-		@game = Game.new(@maze)
+		@maze = Maze.new 8, 8
+        backtrace = Backtrace.new @maze
+		backtrace.generate
+		@game = Game.new @maze
 	end
 
 	it '#select_goal_cell' do
 		selected_cell = @game.select_goal_cell(:hard)
-		expect([selected_cell.x, selected_cell.y]).not_to eq([0, 0])
+		expect(selected_cell.coords).not_to eq([0, 0])
 		expect(selected_cell.connected_neighbours.size).to eq(1)
 	end
 
@@ -16,17 +17,17 @@ describe Game do
 		expect(maze.matrix.flatten).to include(2)
 	end
 
-	it '#generate_goal :easy' do
+	it '#generate_goal :medium' do
 		maze = @game.generate_goal(:medium)
 		expect(maze.matrix.flatten).to include(2)
 	end
 
-	it '#generate_goal :easy' do
+	it '#generate_goal :hard' do
 		maze = @game.generate_goal(:hard)
 		expect(maze.matrix.flatten).to include(2)
 	end
 
-	it '#generate_goal :easy' do
+	it '#generate_goal :random' do
 		maze = @game.generate_goal(:random)
 		expect(maze.matrix.flatten).to include(2)
 	end

data/spec/maze/maze_cell_spec.rb

@@ -2,46 +2,113 @@ describe MazeCell do
 	before do
 		@width = 4
 		@height = 4
-		@maze = MazeBTrace.new(@width, @height)
-		@maze_zero = Maze.new(@width, @height)
+		@maze = Maze.new(@width, @height)
 	end
 
 	it '#initialize' do
+		coords = [1, 0]
+		indices = @maze.coords_to_indices *coords
+		params = indices.clone
+		params.push rand(99)
+		@maze.set_raw_value *params
 		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)
+		expect(maze_cell.coords[0]).to eq(1)
+		expect(maze_cell.coords[1]).to eq(0)
+		expect(maze_cell.value).to eq(params.last)
 	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))
+	it '#value' do
+		coords = [0, 0]
+		params = coords.clone
+		params.push rand(99)
+		@maze.set_value *params
+		maze_cell = @maze.cell *coords
+		expect(maze_cell.value).to eq(params.last)
 	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
+	it '#forward' do
+		maze_cell = @maze.cell 1, 1
+		expect(maze_cell.forward(0)).to eq(@maze.cell(2, 1))
+		expect(maze_cell.forward(1)).to eq(@maze.cell(1, 2))
+	end
+
+	it '#backward' do
+		maze_cell = @maze.cell 1, 1
+		expect(maze_cell.backward(0)).to eq(@maze.cell(0, 1))
+		expect(maze_cell.backward(1)).to eq(@maze.cell(1, 0))
+	end
+
+	it '#has_wall_forward' do
+		@maze.set_raw_value_all 1
+		coords = [1, 1]
+		maze_cell = @maze.cell *coords
+		indices = @maze.coords_to_indices *coords
+		params = indices.clone
+		params[1] += 1
+		params.push 0
+		@maze.set_raw_value *params
+		expect(maze_cell.has_wall_forward(0)).to be_truthy
+		expect(maze_cell.has_wall_forward(1)).to be_falsy
+	end
+
+	it '#has_wall_backward' do
+		@maze.set_raw_value_all 1
+		coords = [1, 1]
+		maze_cell = @maze.cell *coords
+		indices = @maze.coords_to_indices *coords
+		params = indices.clone
+		params[1] -= 1
+		params.push 0
+		@maze.set_raw_value *params
+		expect(maze_cell.has_wall_backward(0)).to be_truthy
+		expect(maze_cell.has_wall_backward(1)).to be_falsy
+	end
+
+	it '#has_wall_forward on border' do
+		@maze.set_raw_value_all 1
+		coords = [@maze.dimensions[0] - 1, @maze.dimensions[1] - 1]
+		maze_cell = @maze.cell *coords
+		expect(maze_cell.has_wall_forward(0)).to be_truthy
+		expect(maze_cell.has_wall_forward(1)).to be_truthy
+	end
+
+	it '#has_wall_backward on border' do
+		@maze.set_raw_value_all 1
+		coords = [0, 0]
+		maze_cell = @maze.cell *coords
+		expect(maze_cell.has_wall_backward(0)).to be_truthy
+		expect(maze_cell.has_wall_backward(1)).to be_truthy
 	end
 
 	it '#connected?' do
-		expect(@maze.cell(0, 0)).not_to be_connected
-		expect(@maze_zero.cell(1, 0)).to be_connected
+		coords = [0, 0]
+		@maze.set_raw_value_all 0
+		maze_cell = @maze.cell *coords
+		expect(maze_cell).to be_connected
+
+		@maze.set_raw_value_all 1
+		maze_cell = @maze.cell *coords
+		expect(maze_cell).not_to be_connected
+
+		indices = @maze.coords_to_indices *coords
+		params = indices.clone
+		params[1] += 1
+		params.push 0
+		@maze.set_raw_value *params
+		expect(maze_cell).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)
+	it '#connected? (3x3)' do
+        maze = Maze.new 3, 3
+		maze.set_raw_value_all 1
+        maze_cell1 = maze.cell 1, 1
+        maze_cell2 = maze.cell 1, 2
+        maze.set_value 1, 1, 0
+        maze.set_value 1, 2, 0
+        maze.connect_cells maze_cell1, maze_cell2
+
+		expect(maze_cell1).to be_connected
 	end
 
 	it '#neighbours' do
@@ -53,6 +120,14 @@ describe MazeCell do
 		expect(neighbours).not_to include(@maze.cell(0, 0))
 	end
 
+	it '#connected_neighbours' do
+		@maze.set_raw_value_all 1
+		expect(@maze.cell(0, 0).connected_neighbours).to be_empty
+
+		@maze.set_raw_value_all 0
+		expect(@maze.cell(0, 0).connected_neighbours).to eq([@maze.cell(1, 0), @maze.cell(0, 1)])
+	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)]
@@ -82,14 +157,8 @@ describe MazeCell do
 		expect(maze_cell != nil).to be_truthy
 	end
 
-	it '#print' do
-		allow($stdout).to receive(:puts).exactly(3).times
-		maze_cell = @maze.cell(0, 0)
-		maze_cell.print
-	end
-
 	it '#inspect' do
 		maze_cell = @maze.cell(1, 0)
-		expect(maze_cell.inspect).to eq("#<MazeCell: @maze=#{@maze.inspect}, @x=#{1}, @y=#{0}>")
+		expect(maze_cell.inspect).to eq("#<MazeCell: @maze=#{@maze.inspect}, @c1=#{1}, @c2=#{0}>")
 	end
 end

data/spec/maze/maze_spec.rb

@@ -1,47 +1,223 @@
 describe Maze do
-	before do
-		@width = rand(10) + 15
-		@height = rand(10) + 15
-		@maze = Maze.new(@width, @height)
+	it '#initialize 2d' do
+		width = rand(10) + 15
+		height = rand(10) + 15
+		maze = Maze.new(width, height)
+		expect(maze.dimensions[0]).to eq(width)
+		expect(maze.dimensions[1]).to eq(height)
+		expect(maze.matrix.length).to eq(width * 2 + 1) # raw dimensions
+		expect(maze.matrix[0].length).to eq(height * 2 + 1) # raw dimensions
 	end
 
-	it '#initialize' do
-		expect(@maze.width).to eq(@width)
-		expect(@maze.height).to eq(@height)
+	it '#initialize Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		matrix_iter = maze.matrix
+		dimensions.each_with_index do |d, d_index|
+			expect(maze.dimensions[d_index]).to eq(dimensions[d_index])
+			expect(matrix_iter.length).to eq(dimensions[d_index] * 2 + 1) # raw dimensions
+			matrix_iter = matrix_iter[0]
+		end
 	end
 
-	it '#value' do
-		expect(@maze.value(0, 0)).to eq(0)
+	it '#total_cells 2d' do
+		maze = Maze.new 4, 8
+        expect(maze.total_cells).to eq(32)
 	end
 
-	it '#cell' do
-		cell = @maze.cell(3, 8)
+	it '#total_cells Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+        expect(maze.total_cells).to eq(maze.dimensions.reduce(1) { |accum, d| accum*d })
+	end
+
+	it '#total_raw 2d' do
+		maze = Maze.new 4, 8
+        expect(maze.total_raw).to eq(9*17)
+	end
+
+    it '#cells 2d (0)' do
+		maze = Maze.new 2, 2
+        expect(maze.cells.length).to eq(4)
+        expect(maze.cells).to eq([[0, 0], [0, 1], [1, 0], [1, 1]].map { |coord| maze.cell *coord })
+    end
+
+    it '#cells 2d (1)' do
+		maze = Maze.new 5, 4
+        expect(maze.cells.length).to eq(20)
+        expect(maze.cells).to eq([[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3],[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3],[4,0],[4,1],[4,2],[4,3]].map { |coord| maze.cell *coord })
+    end
+
+	it '#coords_to_indices 2d' do
+		maze = Maze.new 4, 8
+		x, y = 2, 3
+		i, j = maze.coords_to_indices x, y
+		expect([i, j]).to eq([5, 7])
+	end
+
+	it '#coords_to_indices 3d' do
+		maze = Maze.new 4, 8, 7
+		x, y, z = 2, 3, 1
+		i, j, k = maze.coords_to_indices x, y, z
+		expect([i, j, k]).to eq([5, 7, 3])
+	end
+
+	it '#coords_to_indices Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		indices = maze.coords_to_indices *coords
+		expect(indices).to eq(coords.map { |c| 1 + 2 * c })
+	end
+
+	it '#get_raw_value 2d' do
+		maze = Maze.new 3, 3
+		expect(maze.get_raw_value(0, 0)).to eq(0)
+	end
+
+	it '#get_raw_value Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		indices = maze.coords_to_indices *coords
+		expect(maze.get_raw_value(*indices)).to eq(0)
+	end
+
+	it '#set_raw_value 2d' do
+		maze = Maze.new 3, 3
+		maze.set_raw_value(0, 0, 10)
+		expect(maze.get_raw_value(0, 0)).to eq(10)
+		maze.set_raw_value(2, 5, 20)
+		expect(maze.get_raw_value(2, 5)).to eq(20)
+	end
+
+	it '#set_raw_value Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		value = rand(99) + 1
+		indices = maze.coords_to_indices *coords
+		params = indices.clone
+		params.push value
+		maze.set_raw_value *params
+		expect(maze.get_raw_value(*indices)).to eq(value)
+	end
+
+	it '#set_raw_value_all 2d' do
+		maze = Maze.new 3, 3
+		maze.set_raw_value_all 10
+		coords = maze.dimensions.map { |d| rand(d) }
+		indices = maze.coords_to_indices *coords
+		expect(maze.get_raw_value(*indices)).to eq(10)
+	end
+
+	it '#set_raw_value_all Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		maze.set_raw_value_all 11
+		coords = maze.dimensions.map { |d| rand(d) }
+		indices = maze.coords_to_indices *coords
+		expect(maze.get_raw_value(*indices)).to eq(11)
+	end
+
+	it '#get_value 2d' do
+		maze = Maze.new 3, 3
+		expect(maze.get_value(0, 0)).to eq(0)
+	end
+
+	it '#get_value Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		expect(maze.get_value(*coords)).to eq(0)
+	end
+
+	it '#set_value 2d' do
+		maze = Maze.new 3, 3
+		maze.set_value(0, 0, 10)
+		expect(maze.get_value(0, 0)).to eq(10)
+		maze.set_value(2, 1, 20)
+		expect(maze.get_value(2, 1)).to eq(20)
+	end
+
+	it '#set_value Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		value = rand(99) + 1
+		params = coords.clone
+		params.push value
+		maze.set_value *params
+		expect(maze.get_value(*coords)).to eq(value)
+	end
+
+	it '#cell 2d' do
+		maze = Maze.new 4, 9
+		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)
+		expect(cell.maze).to eq(maze)
+		expect(cell[0]).to eq(3)
+		expect(cell[1]).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])
+	it '#cell Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		coords = dimensions.map { |d| rand(d) }
+		cell = maze.cell *coords
+		expect(cell).to be_a_kind_of(MazeCell)
+		expect(cell.maze).to eq(maze)
+		coords.each_with_index do |c, c_index|
+			expect(cell[c_index]).to eq(c)
+		end
 	end
 
-	it '#generate' do
-		expect(@maze.generate).to eq(@maze)
+    it '#between_cells 2d' do
+		maze = Maze.new 4, 8
+        cell_a = maze.cell 1, 1
+        cell_b = maze.cell 2, 3
+        expect(maze.between_cells(cell_a, cell_b)).to eq([4.0, 5.0])
+        expect(maze.between_cells(cell_a, cell_a)).to eq([3.0, 3.0])
+    end
+
+    it '#connect_cells 2d' do
+		maze = Maze.new 4, 8
+        maze.set_raw_value_all 1
+        cell_a = maze.cell 1, 1
+        cell_b = maze.cell 2, 3
+        indices = maze.between_cells cell_a, cell_b
+        expect(maze.connect_cells(cell_a, cell_b)).to eq(indices)
+        expect(maze.get_raw_value(*indices)).to eq(0)
+    end
+
+    it '#disconnect_cells 2d' do
+		maze = Maze.new 4, 8
+        maze.set_raw_value_all 0
+        cell_a = maze.cell 1, 1
+        cell_b = maze.cell 2, 3
+        indices = maze.between_cells cell_a, cell_b
+        expect(maze.disconnect_cells(cell_a, cell_b)).to eq(indices)
+        expect(maze.get_raw_value(*indices)).to eq(1)
+    end
+
+	it '#hash 2d' do
+		maze = Maze.new 4, 8
+		expect(maze.hash).to eq(48)
 	end
 
-	it '#hash' do
-		expect(@maze.hash).to eq("#{@width}#{@height}".to_i)
+	it '#hash Nd' do
+		dimensions = ([nil]*(rand(10)+3)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		expect(maze.hash).to eq(dimensions.reduce(""){ |accum, d| "#{accum}#{d}" }.to_i)
 	end
 
-	it '#inspect' do
-		expect(@maze.inspect).to eq("#<Maze: @width=#{@width}, @height=#{@height}>")
+	it '#inspect 2d' do
+		maze = Maze.new 3, 6
+		expect(maze.inspect).to eq("#<Maze: @d1=3, @d2=6>")
 	end
 
-	it '#print' do
-		allow($stdout).to receive(:puts).exactly(@maze.height_full).times
-		@maze.print
+	it '#inspect 3d' do
+		maze = Maze.new 1, 5, 7
+		expect(maze.inspect).to eq("#<Maze: @d1=1, @d2=5, @d3=7>")
 	end
 end

data/spec/solver/tree_solver_spec.rb

@@ -1,13 +1,23 @@
 describe TreeSolver do
-	before do
-		@maze = MazeBTrace.new(4, 4)
-		@maze.generate
-		@tree_solver = TreeSolver.new(@maze)
-	end
-
-	it '#paths' do
-		paths = @tree_solver.paths(0, 0)
+	it '#paths 2d' do
+        maze = Maze.new 4, 4
+		backtrace = Backtrace.new maze
+		backtrace.generate
+		tree_solver = TreeSolver.new maze
+		paths = tree_solver.paths 0, 0
 		expect(paths.name).to eq('0,0')
 		expect(paths.size).to eq(16)
 	end
+
+	it '#paths Nd' do
+		dimensions = ([nil]*(rand(4)+2)).map { |_| 1 + rand(4)  }
+		maze = Maze.new *dimensions
+		backtrace = Backtrace.new maze
+		backtrace.generate
+		tree_solver = TreeSolver.new maze
+        start_coords = [0]*dimensions.length
+		paths = tree_solver.paths *start_coords
+		expect(paths.name).to eq(start_coords.map(&:to_s).join(','))
+		expect(paths.size).to be > 0
+	end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,2 @@
-require 'simplecov'
-
-SimpleCov.start
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rmaze
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Pedro Lira
@@ -52,18 +52,19 @@ files:
 - ".ruby-version"
 - Gemfile
 - Gemfile.lock
+- LICENSE.txt
 - README.md
 - Rakefile
 - bin/rmaze
+- lib/algorithm/backtrace.rb
 - lib/game/game.rb
 - lib/maze/maze.rb
-- lib/maze/maze_btrace.rb
 - lib/maze/maze_cell.rb
 - lib/rmaze.rb
 - lib/solver/tree_solver.rb
 - rmaze.gemspec
+- spec/algorithm/backtrace_spec.rb
 - spec/game/game_spec.rb
-- spec/maze/maze_btrace_spec.rb
 - spec/maze/maze_cell_spec.rb
 - spec/maze/maze_spec.rb
 - spec/solver/tree_solver_spec.rb
@@ -88,13 +89,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: RMaze
 test_files:
+- spec/algorithm/backtrace_spec.rb
 - spec/game/game_spec.rb
-- spec/maze/maze_btrace_spec.rb
 - spec/maze/maze_cell_spec.rb
 - spec/maze/maze_spec.rb
 - spec/solver/tree_solver_spec.rb

data/lib/maze/maze_btrace.rb

@@ -1,57 +0,0 @@
-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/spec/maze/maze_btrace_spec.rb

@@ -1,11 +0,0 @@
-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