amaze 0.2.0

data/lib/amaze/grid/polar.rb

@@ -0,0 +1,61 @@
+
+class Amaze::Grid::Polar < Amaze::Grid
+  
+  def initialize rows
+    super rows, 1
+  end
+
+  def prepare_grid
+    @grid = Array.new(rows)
+    @grid[0] = [Amaze::Cell::Polar.new(0, 0)]
+    
+    row_height = 1.0 / rows
+    (1...rows).each do |row|
+      radius = row.to_f / rows
+      circumference = 2 * Math::PI * radius
+      
+      previous_count = @grid[row-1].size
+      estimated_cell_width = circumference / previous_count
+      ratio = (estimated_cell_width / row_height).round
+      
+      cells = previous_count * ratio
+      @grid[row] = Array.new(cells) {|column| Amaze::Cell::Polar.new(row, column) }
+    end
+  end
+  
+  def configure_cell
+    each_cell do |cell|
+      row, column = cell.row, cell.column
+      next if row == 0
+      
+      cell.cw = self[row, column+1]
+      cell.ccw = self[row, column-1]
+      
+      ratio = grid[row].size / grid[row-1].size
+      parent = self[row-1, column/ratio]
+      parent.outward << cell
+      cell.inward = parent
+    end
+  end
+  
+  def columns row
+    grid[row]
+  end
+  
+  def [](row, column)
+    return nil unless row.between?(0, rows-1)
+    grid[row][column % columns(row).size]
+  end
+  
+  def random_cell
+    row = rand rows
+    column = rand grid[row].size
+    self[row, column]
+  end
+  
+  def size
+    count = 0
+    each_row {|row| count += row.size }
+    count
+  end
+end

data/lib/amaze/grid/sigma.rb

@@ -0,0 +1,61 @@
+
+class Amaze::Grid::Sigma < Amaze::Grid
+  
+  def prepare_grid
+    @grid = Array.new(rows) do |row|
+      Array.new(columns) do |column|
+        Amaze::Cell::Hex.new row, column
+      end
+    end
+  end
+  
+  def configure_cell
+    each_cell do |cell|
+      row, column = cell.row, cell.column
+      
+      cell.north = self[row-1, column] 
+      cell.south = self[row+1, column]
+
+      if column.even?
+        cell.northeast = self[row-1, column+1]
+        cell.southeast = self[row,column+1]
+        cell.northwest = self[row-1, column-1]
+        cell.southwest = self[row, column-1]
+      else
+        cell.northeast = self[row, column+1]
+        cell.southeast = self[row+1,column+1]
+        cell.northwest = self[row, column-1]
+        cell.southwest = self[row+1, column-1]
+      end
+    end
+  end
+end
+
+__END__
+
+ __    __    __
+/  \__/  \__/  \__
+\__/  \__/  \__/  \
+/  \__/  \__/  \__/
+\__/  \__/  \__/  \
+/  \__/  \__/  \__/
+\__/  \__/  \__/  \
+/  \__/  \__/  \__/
+\__/  \__/  \__/  \
+   \__/  \__/  \__/
+
+  ______          ______          ______
+ /      \        /      \        /      \
+/        \______/        \______/        \______
+\        /      \        /      \        /      \
+ \______/        \______/        \______/        \
+ /      \        /      \        /      \        /
+/        \______/        \______/        \______/
+\        /      \        /      \        /      \
+ \______/        \______/        \______/        \
+ /      \        /      \        /      \        /
+/        \______/        \______/        \______/
+\        /      \        /      \        /      \
+ \______/        \______/        \______/        \
+        \        /      \        /      \        /
+         \______/        \______/        \______/

data/lib/amaze/grid/upsilon.rb

@@ -0,0 +1,74 @@
+class Amaze::Grid::Upsilon < Amaze::Grid
+  
+  def prepare_grid
+    @grid = Array.new(rows) do |row|
+      Array.new(columns) do |column|
+        if (row+column).even?
+          Amaze::Cell::Octo.new row, column
+        else
+          Amaze::Cell::Square.new row, column
+        end
+      end
+    end
+  end
+  
+  def configure_cell
+    each_cell do |cell|
+      row, column = cell.row, cell.column
+
+      cell.north = self[row-1, column]
+      cell.east = self[row, column+1]
+      cell.south = self[row+1, column]
+      cell.west = self[row, column-1]
+
+      # Octo
+      if (cell.row+cell.column).even?
+        cell.northeast = self[row-1, column+1]
+        cell.southeast = self[row+1, column+1]
+        cell.southwest = self[row+1, column-1]
+        cell.northwest = self[row-1, column-1]
+      end
+    end
+  end
+end
+
+__END__
+
+  +---+       +---+       +---+      
+ /     \     /     \     /     \     
++       +---+       +---+       +---+
+|       |   |       |   |       |   |
++       +---+       +---+       +---+
+ \     /     \     /     \     /     \
+  +---+       +---+       +---+       +
+  |   |       |   |       |   |       |
+  +---+       +---+       +---+       +
+ /     \     /     \     /     \     /
++       +---+       +---+       +---+
+|       |   |       |   |       |   |
++       +---+       +---+       +---+
+ \     /     \     /     \     /     \
+  +---+       +---+       +---+       +
+  |   |       |   |       |   |       |
+  +---+       +---+       +---+       +
+ /     \     /     \     /     \     /
++       +---+       +---+       +---+
+|       |   |       |   |       |   |
++       +---+       +---+       +---+
+ \     /     \     /     \     /     
+  +---+       +---+       +---+      
+
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     

data/lib/amaze/mask.rb

@@ -0,0 +1,75 @@
+
+require 'chunky_png'
+
+class Amaze::Mask
+  
+  # The rows and columns of the mask
+  attr_reader :rows, :columns
+  
+  def initialize rows, columns
+    @rows, @columns = rows, columns
+    @bits = Array.new(@rows) { Array.new(@columns, true) }
+  end
+  
+  def [](row, column)
+    if row.between?(0, rows - 1) && column.between?(0, columns - 1)
+      @bits[row][column]
+    else
+      false
+    end
+  end
+  
+  def []=(row, column, is_on)
+    @bits[row][column] = is_on
+  end
+  
+  def count
+    count = 0
+    
+    rows.times do |row|
+      columns.times do |column|
+        count += 1 if @bits[row][column]
+      end
+    end
+    count
+  end
+  
+  def random_location
+    loop do
+      row = rand(rows)
+      column = rand(columns)
+      return [row, column] if @bits[row][column]
+    end
+  end
+  
+  def self.from_txt file
+    lines = File.readlines(file).map(&:strip)
+    lines.pop while lines.last.length < 1
+    
+    rows = lines.length
+    columns = lines.first.length
+    mask = new rows, columns
+    
+    mask.rows.times do |row|
+      mask.columns.times do |column|
+        mask[row,column] = lines[row][column] != 'X'
+      end
+    end
+    
+    mask
+  end
+  
+  def self.from_png file
+    image = ChunkyPNG::Image.from_file file
+    mask = new image.height, image.width
+
+    mask.rows.times do |row|
+      mask.columns.times do |column|
+        mask[row,column] = image[column, row] != ChunkyPNG::Color::BLACK
+      end
+    end
+    
+    mask
+  end
+
+end

data/lib/amaze/masked_grid.rb

@@ -0,0 +1,29 @@
+
+module Amaze::MaskedGrid
+  
+  # The mask
+  attr_reader :mask
+  
+  def initialize mask
+    @mask = mask
+    super mask.rows, mask.columns
+  end
+  
+  def prepare_grid
+    super
+
+    each_cell do |cell|
+      row, column = cell.row, cell.column
+      grid[row][column] = nil unless mask[row, column]
+    end
+  end
+  
+  def random_cell
+    row, column = mask.random_location
+    self[row, column]
+  end
+  
+  def size
+    mask.count
+  end
+end

data/lib/amaze/script.rb

@@ -0,0 +1,361 @@
+
+require 'optparse'
+require 'io/console'
+require 'rainbow/ext/string'
+require 'rmagick'
+
+class Amaze::Script
+
+  attr_reader :seed
+
+  attr_reader :options
+
+  def initialize
+    # default options
+    @options = {
+      type: :ortho, 
+      distances: false,
+      formats: [:ascii],
+      algorithm: :gt1,
+      visualize: false,
+    }
+  end
+
+  def parser
+    OptionParser.new do |o|
+      o.banner = "\nMaze generator\n\nUsage: #{File.basename $0} [options]\n"
+      o.separator "\nGrid options:"
+
+      o.on('-t', '--type TYPE', Amaze::Factory.types, 'The type of the maze.', "One of #{Amaze::Factory.types.join(', ')}") do |type|
+        options[:type] = type
+      end
+      o.on('-g', '--grid-size ROWS[,COLUMNS]', Array, 'The size of the grid.') do |v|
+        options[:grid_size] = Array(v).map(&:to_i)
+      end
+      o.on('-m', '--mask MASKFILE', String, 'MASKFILE is either a ASCII file or a PNG file.') do |mask|
+        options[:mask] = mask
+      end
+      o.on('-s', '--shape SHAPE', Amaze::Factory.shapes, "One of #{Amaze::Factory.shapes.join(', ')}.", "Shapes won't work on polar mazes.") do |shape|
+        options[:shape] = shape
+      end
+  
+      o.separator "\nAlgorithm options:"
+
+      o.on('-a', '--algorithm ALGORITHM', Amaze::Factory.algorithms, 'The algorithm to generate the maze.', "One of #{Amaze::Factory.algorithms.join(', ')}") do |algorithm|
+        options[:algorithm] = algorithm
+      end
+      o.on('-S', '--seed SEED', Integer, 'Set random seed') do |seed|
+        options[:seed] = seed
+      end
+      visualization_modes = [:run, :runsegment, :segment, :step]
+      o.on('-v', '--visualize [MODE]', visualization_modes, 'Visualize the progress of the algorithm', "One of #{visualization_modes.join(', ')}") do |mode|
+        options[:visualize] = mode || :run
+      end
+
+      o.separator "\nSolution options:"
+
+      o.on('--[no-]distances [ROW,COLUMN]', Array, 'Calculate the distances from cell(ROW/COLUMN) to all other cells of the grid.') do |distances|
+        options[:distances] = distances ? distances.map(&:to_i) : :auto
+      end
+      o.on('--[no-]solution [ROW,COLUMN]', Array, 'Find the shortest path to cell(ROW/COLUMN).') do |solution|
+        options[:solution] = solution ? solution.map(&:to_i) : :auto
+      end
+      o.on('--[no-]longest', 'Find the longest path of the maze.') do |longest|
+        options[:longest] = longest
+      end
+  
+      o.separator "\nRender Options:"
+  
+      o.on('-f', '--format [FORMAT,...]', Array, 'Render the maze on the given formats.') do |formats|
+        options[:formats] = formats.map(&:to_sym)
+      end
+
+      o.separator "\nASCII Options:"
+  
+      o.on('-c', '--cell-size SIZE', Integer, 'The size of the cell') do |cell_size|
+        options[:cell_size] = cell_size
+      end
+      o.on('--grid-color NAME', Rainbow::X11ColorNames::NAMES.keys, 'The color of the grid.') do |color|
+        options[:ascii_grid_color] = color
+      end
+      o.on('--path-color NAME', Rainbow::X11ColorNames::NAMES.keys, 'The color of the path, when drawing the solution or longest path.') do |color|
+        options[:ascii_path_color] = color
+      end
+      o.on('--distances-color NAME', Rainbow::X11ColorNames::NAMES.keys, 'The color of the distances.') do |color|
+        options[:ascii_distances_color] = color
+      end
+      o.on('--all-ascii-colors', 'Print all the supported ascii colors.') do
+        puts Rainbow::X11ColorNames::NAMES.keys.map {|n| n.to_s.color(n) }.join(' ')
+        exit 0
+      end
+
+      o.separator "\nImage Options:"
+  
+      o.on('--cell-width PIXEL', Integer, 'The width of a cell.') do |px|
+        options[:image_cell_width] = px
+      end
+      o.on('--wall-width PIXEL', Integer, 'The width of the walls.') do |px|
+        options[:image_wall_width] = px
+      end
+      o.on('--wall-color NAME', Magick.colors.map(&:name), 'The color of the walls.') do |color|
+        options[:image_wall_color] = color
+      end
+      o.on('--path-width PIXEL', Integer, 'The width of the path.') do |px|
+        options[:image_path_width] = px
+      end
+      o.on('--path-color NAME', Magick.colors.map(&:name), 'The color of the path.') do |color|
+        options[:image_path_color] = color
+      end
+      o.on('--border-width PIXEL', Integer, 'The width of the border around the maze.') do |px|
+        options[:image_border_width] = px
+      end
+      o.on('--background-color NAME', Magick.colors.map(&:name), 'The background color.') do |color|
+        options[:image_background_color] = color
+      end
+      o.on('--show-grid', 'Render the underlying grid.') do
+        options[:image_show_grid] = true
+      end
+      o.on('--hide-walls', "Don't render the walls.") do
+        options[:image_hide_walls] = true
+      end
+      o.on('--gradient-map NAME', Amaze::Factory.gradient_maps, 'The gradient map to use for the distances color.', "One of #{Amaze::Factory.gradient_maps.join(', ')}") do |map|
+        options[:gradient_map] = map
+      end
+      o.on('--all-image-colors', 'Print all the supported image colors.') do
+        puts Magick.colors.map(&:name).join(', ')
+        exit 0
+      end
+
+      o.separator ""
+    end
+  end
+  
+  def run args
+    parser.parse!(args)
+    
+    initialize_random_seed
+    
+    # Run the algorithm on the grid
+    if visualize?
+      algorithm.on grid do |stat|
+        # print the maze
+        ascii = factory.create_ascii_formatter grid,
+          ascii_options(path_color: :blue, path_cells: stat.current)
+          
+        puts ascii.render
+        
+        puts stat.info if stat.info
+        sleep algorithm.speed
+        sleep 1 if options[:visualize] == :runsegment && stat.pause?
+  
+        # wait for keystroke ?
+        if (options[:visualize] == :segment && stat.pause? || options[:visualize] == :step)
+          case read_char
+          when "\e"
+            break
+          when "r"
+            options[:visualize] = :run
+          end
+        end
+      end
+    else
+      algorithm.on grid
+    end
+    
+    ascii_runtime_options = {}
+    image_runtime_options = {}
+    
+    # Calculate the distances from a given start cell
+    if distances?
+      distances = start_cell.distances
+      ascii_runtime_options[:distances] = distances
+      image_runtime_options[:distances] = distances
+    end
+
+    # And the solution to a given end cell
+    if solution?
+      distances = start_cell.distances.path_to finish_cell
+      ascii_runtime_options[:path_cells] = distances.cells
+      image_runtime_options[:path_cells] = distances.cells
+      image_runtime_options[:path_start] = start_cell
+      image_runtime_options[:path_finish] = finish_cell
+      path_length = distances[finish_cell]
+    end
+    
+    if longest?
+      new_start, distance = start_cell.distances.max
+      new_distances = new_start.distances
+      new_finish, distance = new_distances.max
+      distances = new_distances.path_to new_finish
+      image_runtime_options[:distances] = new_distances if distances?
+      ascii_runtime_options[:path_cells] = distances.cells
+      image_runtime_options[:path_cells] = distances.cells
+      image_runtime_options[:path_start] = new_start
+      image_runtime_options[:path_finish] = new_finish
+      path_length = distance
+    end
+
+    # Render the maze, set defaults for missing options
+    if ascii?
+      ascii = factory.create_ascii_formatter grid, ascii_options(ascii_runtime_options)
+      puts ascii.render
+    end
+    
+    puts algorithm.status
+    puts "Dead ends: #{grid.deadends.size} of #{grid.size} (#{(100.to_f / grid.size * grid.deadends.size).to_i}%)"
+    puts "Path length: #{path_length}" if path_length
+    puts "Random seed: #{seed}"
+
+    if image?
+      image = factory.create_image_formatter grid,
+        image_options(image_runtime_options)
+      image.render
+      
+      # TODO: write multiple images with solution and distances
+      #       or a psd file with layers
+      
+      image.write "maze.png"
+      puts "Maze 'maze.png' saved."
+    end
+  end
+    
+  def ascii_options runtime_options={}
+    { 
+      cell_size: options[:cell_size] || 1,
+      grid_color: options[:ascii_grid_color] || :white,
+      path_color: options[:ascii_path_color] || :red,
+      distances_color: options[:ascii_distances_color]
+    }.merge runtime_options
+  end
+  
+  def image_options runtime_options={}
+    {
+      cell_width: options[:image_cell_width] || 100,
+      wall_width: options[:image_wall_width] || 6,
+      wall_color: options[:image_wall_color] || 'black',
+      path_width: options[:image_path_width] || 4,
+      path_color: options[:image_path_color] || 'red',
+      border_width: options[:image_border_width] || 0,
+      background_color: options[:image_background_color] || 'white',
+      show_grid: options[:image_show_grid] || false,
+      hide_walls: options[:image_hide_walls] || false,
+      gradient_map: factory.gradient_map(options[:gradient_map] || :warm),
+    }.merge runtime_options
+  end
+  
+  def ascii?
+    @options[:formats].include? :ascii
+  end
+  
+  def image?
+    @options[:formats].include? :image
+  end
+  
+  def visualize?
+    ascii? && !!@options[:visualize]
+  end
+  
+  def distances?
+    !!@options[:distances]
+  end
+  
+  def solution?
+    !!@options[:solution]
+  end
+  
+  def longest?
+    !!@options[:longest]
+  end
+  
+  # TODO: specify a start cell should also work for polar grids
+  
+  def start_cell
+    if @options[:type] == :polar
+      grid[grid.rows-1, 0]
+    else
+      if !@options[:distances] || @options[:distances] == :auto
+        column = grid.columns.times.find {|i| grid[0,i] }
+        return grid[0,column] if column
+        row = grid.rows.times.find {|i| grid[i,0] }
+        return grid[row,0]
+      else
+        grid[*@options[:distances]]
+      end
+    end
+  end
+  
+  # TODO: specify a finish cell should also work for polar grids
+  
+  def finish_cell
+    if @options[:type] == :polar
+      row = grid.rows-1
+      columns = grid.columns row
+      grid[row, columns.size / 2]
+    else
+      if !@options[:solution] || @options[:solution] == :auto
+        column = grid.columns.times.find {|i| grid[grid.rows-1,grid.columns-1-i] }
+        return grid[grid.rows-1,grid.columns-1-column] if column
+        row = grid.rows.times.find {|i| grid[grid.rows-1-i,grid.columns-1] }
+        return grid[grid.rows-1-row,grid.columns-1]
+      else
+        grid[*@options[:solution]]
+      end
+    end
+  end
+  
+  def factory
+    @factory ||= Amaze::Factory.new options[:type]
+  end
+  
+  def grid
+    @grid ||= if options[:mask]
+      factory.create_masked_grid options[:mask]
+    elsif options[:shape]
+      factory.create_shaped_grid options[:shape], *grid_size
+    else
+      factory.create_grid *grid_size
+    end
+  end
+  
+  def grid_size
+    # double the columns for delta grids if not specified
+    if options[:grid_size]
+      size = options[:grid_size].first(2).map(&:to_i)
+      size[1] ||= (options[:type] == :delta ? options[:grid_size][0] * 2 : options[:grid_size][0])
+    else
+      size = [4, options[:type] == :delta ? 8 : 4]
+    end
+    size = size.first if options[:type] == :polar
+    size
+  end
+  
+  def algorithm
+    @algorithm ||= factory.create_algorithm options[:algorithm]
+  end
+  
+  def initialize_random_seed
+    if options[:seed]
+      @seed = options[:seed]
+    else
+      srand
+      @seed = srand
+    end
+    srand @seed
+  end
+  
+  # Reads keypresses from the user including 2 and 3 escape character sequences.
+  def read_char
+    STDIN.echo = false
+    STDIN.raw!
+
+    input = STDIN.getc.chr
+    if input == "\e" then
+      input << STDIN.read_nonblock(3) rescue nil
+      input << STDIN.read_nonblock(2) rescue nil
+    end
+  ensure
+    STDIN.echo = true
+    STDIN.cooked!
+    return input
+  end
+end