maze_solver 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dce2968fbc1b982e1bc809b3c04721d97a5b011a
+  data.tar.gz: bdb569186748d7521587601d64f95440794d886d
+SHA512:
+  metadata.gz: 6315411ca831fdd12408374e8a515ad11653c854bba934934bf308da8a49474e1f345f7689268cac5a6db7eb1a3a0a76a8fdf51926c82422d6a1f7adda478aeb
+  data.tar.gz: 609cef963ec700f6aadd4bf0fb0819315b1e3edfcb405f44d7c4d38ed1134345855785d386a3750b4ab00d48d794ba86a7839d5f2a253d0b0922e902580ba31d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in maze_solver.gemspec
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+# MazeSolver
+
+This is a Maze Solver for labyrinths with specific format
+_ : PATH
+X : WALL
+S : START
+G : GOAL (EXIT)
+
+It finds the shortest Path using A* Algorithm
+
+## Use
+
+```Ruby
+  require 'maze_solver'
+
+  MazeSolver.to_image('file_name')
+
+  MazeSolver.to_json('file_name')
+```
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :console do
+  exec "irb -r mygem -I ./lib"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "maze_solver"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/maze_solver.rb

@@ -0,0 +1,73 @@
+require "maze_solver/version"
+require "maze_solver/position"
+require "maze_solver/element"
+require "maze_solver/maze"
+require "json"
+
+module MazeSolver
+
+  ## Better to implemented on a class after thoughts......Anyway..mabe later!!!
+
+  def to_json(file_name)
+    
+    maze_array = from_file(file_name)
+    maze_list = to_maze(maze_array)
+    maze = Maze.new(maze_list)
+    solution = maze.solve
+
+    solution_array = solution.map do |element|
+      { value: element.value, position: "(#{element.position.x}, #{element.position.y})" }
+    end
+
+    JSON.generate(solution_array)
+  end
+
+  def to_image(file_name)
+    ## Print solution to console
+    maze_array = from_file(file_name)
+    maze_list = to_maze(maze_array)
+    maze = Maze.new(maze_list)
+    solution = maze.solve
+
+    maze_list.each do |element|
+      maze_array[element.position.y][element.position.x] = '*' if solution.find { |se| se == element }
+    end
+
+    puts '!!!!!!!SOLUTIOM!!!!!!!'
+    print maze_array.join('')
+
+    nil
+  end
+
+  def from_file(file_name)
+    ## Read file and export it to a 2D array
+    ## Throw error if file doesnt exist
+
+    begin
+      File.readlines(file_name).map { |line| line.split('') }
+    rescue abort("can't open #{file_name}" )
+    end
+  end
+
+  def to_maze(maze_array)
+    maze = []  
+    maze_array.each_with_index do |line, line_index|
+      line.each_with_index do |char, col_index|
+        case char
+          when '_' 
+            then maze << Element.new(char, Position.new(col_index, line_index,), 'PATH')
+          when 'X'
+            then maze << Element.new(char, Position.new(col_index, line_index,), 'WALL')
+          when 'S'
+            then maze << Element.new(char, Position.new(col_index, line_index,), 'START')
+          when 'G'
+            then maze <<  Element.new(char, Position.new(col_index, line_index,), 'GOAL' )
+        end
+      end
+    end
+    maze
+  end
+
+  module_function :to_json, :to_image, :from_file, :to_maze
+end
+

data/lib/maze_solver/element.rb

@@ -0,0 +1,47 @@
+module MazeSolver
+  class Element
+    ## Represent an element in the Maze, defined by his position and value
+    ## There are also some Astar factors like g, h, f functions
+    ## Also the precedent element, (parent)
+    ## visited is a flag that aknowledge that the element had been visited
+    
+    attr_accessor :g, :h, :f, :parent
+    attr_reader :value, :position, :type
+
+    def to_s
+      ## Represent the class
+      "(#{@position}), #{@value}"
+    end
+
+    def ==(element)
+      ## Compare two elements by its position
+      return true if ( @position == element.position && @value == element.value && @type == element.type )
+      return false
+    end
+
+    def initialize(value, position, type)
+      @value = value
+      @position = position
+      @type = type
+
+      ## Default Astar values
+      @g = 0
+      @h = 0
+      @f = 0
+      @parent = nil
+    end
+
+    def is_goal?
+      ## is the end point?
+      return true if  @type == 'GOAL' 
+      false
+    end
+
+    def is_path?
+      ## Can be traversed?
+      return true if ( @type == 'PATH' ||  @type == 'START' || @type == 'GOAL' )
+      false
+    end
+
+  end
+end

data/lib/maze_solver/maze.rb

@@ -0,0 +1,128 @@
+require "maze_solver/tree"
+
+module MazeSolver
+  class Maze
+    ## Class which Represent the maze
+
+    attr_reader :maze
+
+    def initialize(maze)
+      @maze = maze
+      @closed = [] # Already proccessed
+
+      set_start_and_goal
+    end
+
+    def solve
+      ## Begin process !!
+      tree = Tree.new # Instanciate a tree with start point as first pushing
+      tree.push(@start, @start.f)
+
+      reverse_path( algorithm(tree) ) # RUUUN
+    end
+
+    private
+
+    def algorithm(tree)
+      ## Core of this gem
+      ## Recurcive implementetion
+
+      element = tree.next
+      @closed.push(element)
+
+      return element if element.is_goal? ## Found EXIT!!!!
+
+      neighbors(element).each do |neighbor|
+        if !in_closed?(neighbor)
+       
+          if tree.in?(neighbor, neighbor.f)
+            if neighbor.g > element.g + 1
+              update_neighbor(neighbor, element)
+            end
+          else
+
+            update_neighbor(neighbor, element)
+            tree.push(neighbor, neighbor.f)
+          end
+        end
+      end
+
+      algorithm(tree)
+    end
+
+    def set_start_and_goal
+      ## Check and set if there is start and goal point
+      start = []
+      goal = []
+
+      @maze.each do |elem|
+        start << elem if elem.type == 'START'
+        goal << elem if elem.type == 'GOAL'
+      end
+
+      abort('Check if there is exactly 
+        one start and one end point') if (start.length != 1 || goal.length != 1 )
+
+      @start = start.pop
+      @goal = goal.pop
+    end
+
+    def reverse_path(element, acc=[])
+      ## Recurcively find path
+      return acc << element if element == @start
+
+      acc << element
+      reverse_path(element.parent, acc)
+    end
+
+    def in_closed?(element)
+      ## Is the element proccessed?
+      @closed.find { |ce| ce == element }
+    end
+
+    def h(element)
+      ## heuristic function (Guessing distance to goal)
+      ## I implement it this way can be implement it with another way
+      ( @goal.position.x - element.position.x ).abs + 
+        ( @goal.position.y - element.position.y ).abs
+    end
+
+    def valid_neighbor(position)
+      ## Check if neighbor is a valid path (_, G, S )
+      neighbor = @maze.find { |elem| elem.position == position }
+
+      if (neighbor)
+        return neighbor if neighbor.is_path?
+      end 
+      nil
+    end
+
+    def neighbors(element)
+      ## Adjacent Elements !!Only valid ones!!
+      neighbors = []
+
+      directions = [ 
+        element.position.north,
+        element.position.east,
+        element.position.south,
+        element.position.west 
+      ]
+
+      directions.each do |d|
+        neighbor = valid_neighbor(d)
+        neighbors << neighbor if neighbor
+      end
+      neighbors
+    end
+
+    def update_neighbor(neighbor, element)
+      ## process neighbor
+
+      neighbor.g = element.g + 1
+      neighbor.h = h(neighbor)
+      neighbor.f = neighbor.g + neighbor.h
+      neighbor.parent = element
+    end
+
+  end
+end

data/lib/maze_solver/position.rb

@@ -0,0 +1,38 @@
+module MazeSolver
+  class Position
+    ## Position Of Element in the maze  (Cartesians)##
+    attr_reader :x, :y # column, row position respectively
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    def ==(position)
+      ## Compare two positions ##
+      @x == position.x && @y == position.y
+    end
+
+    def to_s
+      ## Represent a Position ##
+      "(#{@x}, #{@y})"
+    end
+
+    ## Adjacent position (In a Cartesian way) ##
+    def north
+      Position.new(@x, @y-1)
+    end
+
+    def east
+      Position.new(@x+1, @y)
+    end
+
+    def south
+      Position.new(@x, @y+1)
+    end
+
+    def west
+      Position.new(@x-1, @y)
+    end
+  end
+end

data/lib/maze_solver/tree.rb

@@ -0,0 +1,48 @@
+module MazeSolver
+  class Tree
+    ## Binary Tree Interprentation for Apress Open List
+    def initialize
+      ## Tree in hash form with priority as key and array 
+      ## of elements as value
+      @tree = Hash.new { |hash, key| hash[key] = [] }
+    end
+     
+    def to_s
+      ## Representation of Tree
+      o = '{'
+      @tree.each do |k, v|
+        o += ":#{k} => [\n" 
+        v.each do |el|
+          o += "#{el} \n"
+        end
+        o+="\n]\n"
+      end
+      o += "}"
+    end
+
+    def push(element, priority)
+      ## push an element in the stack
+      @tree[priority] << element
+    end
+
+    def in?(element, priority)
+      ## check if elements is in the stack
+      if @tree.has_key?(priority)
+        return true if @tree[priority].find { |elem| elem == element }
+      end
+      false
+    end  
+    
+    def next
+      ## Poping an element
+
+      return nil if @tree.empty?
+       
+      priority, element = *@tree.min # get the min priority
+      result = element.shift # get the first element 
+      @tree.delete(priority) if element.empty? # if branch with this priority is empty delete it
+      
+      return result
+    end
+  end
+end

data/lib/maze_solver/version.rb

@@ -0,0 +1,3 @@
+module MazeSolver
+  VERSION = "0.1.1"
+end

data/maze_solver.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'maze_solver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "maze_solver"
+  spec.version       = MazeSolver::VERSION
+  spec.authors       = ["Ioannis-Andreas Philippas"]
+  spec.email         = ["ioannis.philippas@gmail.com"]
+
+  spec.summary       = 'Solve maze with astar and simple algorithm'
+  spec.description   = 'Solve maze with astar and simple algorithm'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: maze_solver
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ioannis-Andreas Philippas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Solve maze with astar and simple algorithm
+email:
+- ioannis.philippas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/maze_solver.rb
+- lib/maze_solver/element.rb
+- lib/maze_solver/maze.rb
+- lib/maze_solver/position.rb
+- lib/maze_solver/tree.rb
+- lib/maze_solver/version.rb
+- maze_solver.gemspec
+homepage: 
+licenses: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Solve maze with astar and simple algorithm
+test_files: []