amaze 0.2.0

data/lib/amaze/algorithm/recursive_backtracker.rb

@@ -0,0 +1,77 @@
+
+class Amaze::Algorithm::RecursiveBacktracker < Amaze::Algorithm
+  
+  def initialize
+    @implementation = :stack
+  end
+  
+  def configure implementation
+    @implementation = implementation
+  end
+  
+  def work grid, &block
+    case @implementation
+    when :recursion
+      carve [grid.random_cell], &block
+    when :stack
+      work_with_stack [grid.random_cell], &block
+    end
+  end
+
+  # implementation with explicit stack
+  def work_with_stack stack, &block
+    while stack.any?
+      current = stack.last
+      unvisited_neighbors = current.neighbors.select {|c| c.links.empty? }
+
+      yield Stat.new(                                # visualize
+        current: stack,                              #
+        pause: segment?(unvisited_neighbors),        #
+        info: "Path: #{stack.size}") if block_given? #
+      
+      if unvisited_neighbors.any?
+        neighbor = unvisited_neighbors.sample
+        current.link neighbor
+        stack << neighbor
+      else
+        stack.pop
+      end
+    end
+  end
+  
+  # implementation with recursion
+  def carve path, &block
+    current = path.last
+
+    while current
+      unvisited_neighbors = current.neighbors.select {|c| c.links.empty? }
+
+      yield Stat.new(                               # visualize
+        current: path,                              #
+        pause: segment?(unvisited_neighbors),       #
+        info: "Path: #{path.size}") if block_given? #
+
+      if unvisited_neighbors.any?
+        neighbor = unvisited_neighbors.sample
+        current.link neighbor
+        carve [*path, neighbor], &block
+      else
+        current = nil
+      end
+    end
+  end
+  
+  def segment? unvisited_neighbors
+    @forward = true if @forward.nil?
+    if unvisited_neighbors.empty? && @forward || unvisited_neighbors.any? && !@forward
+      @forward = !@forward
+      true
+    else
+      false
+    end
+  end
+
+  def status
+    "Recursive Backtracker (#{@implementation}) algorithm: #{duration}s"
+  end
+end

data/lib/amaze/algorithm/sidewinder.rb

@@ -0,0 +1,42 @@
+
+class Amaze::Algorithm::Sidewinder < Amaze::Algorithm
+
+  def work grid
+    run = []
+    grid.each_cell do |cell|
+      run << cell
+      
+      dig_north = cell.north && (!cell.east || rand(2) == 0)
+      
+      yield Stat.new(                                 # visualize
+        current: run,                                 #
+        pause: dig_north,                             #
+        info: "Run set: #{run.size}") if block_given? #
+      
+      # dig north if there is a cell north AND
+      #   you can't dig east OR
+      #   you choose randomly
+      if dig_north
+        # dig north (choose one cell of the run set)
+        run.sample.tap {|c| c.link c.north }
+      
+      # dig east if there is a cell east
+      elsif cell.east
+        # dig east (keep run set)
+        cell.link cell.east
+        next
+      end
+
+      run.clear
+    end
+    grid
+  end
+  
+  def speed
+    0.1
+  end
+  
+  def status
+    "Sidewinder algorithm: #{duration}s"
+  end
+end

data/lib/amaze/algorithm/wilson.rb

@@ -0,0 +1,54 @@
+
+class Amaze::Algorithm::Wilson < Amaze::Algorithm
+  
+  def work grid
+    
+    # initialize
+    unvisited = []
+    grid.each_cell {|cell| unvisited << cell }
+    
+    # pick randon cell and remove from unvisited
+    start = unvisited.sample
+    unvisited.delete start
+    
+    while unvisited.any?
+      cell = unvisited.sample
+      path = [cell]
+      
+      # loop erased walk
+      while unvisited.include? cell
+        cell = cell.neighbors.sample
+
+        if path.include? cell
+          path = path[0..path.index(cell)]
+        else
+          path << cell
+        end
+
+        yield Stat.new(                                   # visualize
+          current: [start, *path].compact,                #
+          pause: ! unvisited.include?(cell),              #
+          info: "Path: #{path.size}") if block_given?     #
+
+      end
+      
+      # carve path
+      carved = 0                                          # visualize
+      path.each_cons(2) do |cell1, cell2|
+        cell1.link cell2
+        unvisited.delete cell1
+        
+        yield Stat.new(                                   # visualize
+          current: path,                                  #
+          pause: cell2 == path.last,                      #
+          info: "Carved: #{carved += 1}") if block_given? #
+
+      end
+      start = nil                                         # visualize
+    end
+  end
+  
+  def status
+    "Wilson algorithm: #{duration}s"
+  end
+end

data/lib/amaze/cell.rb

@@ -0,0 +1,63 @@
+
+class Amaze::Cell
+  autoload :Square, 'amaze/cell/square'
+  autoload :Hex, 'amaze/cell/hex'
+  autoload :Octo, 'amaze/cell/octo'
+  autoload :Polar, 'amaze/cell/polar'
+  
+  # The position of the cell in the grid
+  attr_reader :row, :column
+  
+  def initialize row, column
+    @row = row
+    @column = column
+    
+    @links = {}
+  end
+  
+  def links
+    @links.keys
+  end
+  
+  def link cell, bidi=true
+    @links[cell] = true
+    cell.link self, false if bidi
+  end
+  
+  def linked? cell
+    @links.key? cell
+  end
+  
+  def linked_to? direction
+    @links.key? self.send(direction)
+  end
+  
+  def inspect
+    "cell(#{row},#{column})"
+  end
+  
+  def to_s
+    "(#{row},#{column})"
+  end
+  
+  def distances
+    distances = Amaze::Distances.new self
+    frontier = [self]
+    
+    while frontier.any?
+      new_frontier = []
+      
+      frontier.each do |cell|
+        cell.links.each do |linked|
+          next if distances[linked]
+          distances[linked] = distances[cell] + 1
+          new_frontier << linked
+        end
+      end
+      
+      frontier = new_frontier
+    end
+    
+    distances
+  end
+end

data/lib/amaze/cell/hex.rb

@@ -0,0 +1,10 @@
+
+class Amaze::Cell::Hex < Amaze::Cell
+  
+  # The neighbor cells
+  attr_accessor :north, :northeast, :southeast, :south, :northwest, :southwest
+  
+  def neighbors
+    [north, northeast, southeast, south, northwest, southwest].compact
+  end
+end

data/lib/amaze/cell/octo.rb

@@ -0,0 +1,10 @@
+
+class Amaze::Cell::Octo < Amaze::Cell
+  
+  # The neighbor cells
+  attr_accessor :north, :northeast, :east, :southeast, :south, :northwest, :west, :southwest
+  
+  def neighbors
+    [north, northeast, east, southeast, south, northwest, west, southwest].compact
+  end
+end

data/lib/amaze/cell/polar.rb

@@ -0,0 +1,16 @@
+
+class Amaze::Cell::Polar < Amaze::Cell
+  
+  # The neighbor cells
+  attr_accessor :cw, :ccw, :inward
+  attr_reader :outward
+  
+  def initialize(row, column)
+    super
+    @outward = []
+  end
+  
+  def neighbors
+    [cw, ccw, inward, *outward].compact
+  end
+end

data/lib/amaze/cell/square.rb

@@ -0,0 +1,10 @@
+
+class Amaze::Cell::Square < Amaze::Cell
+  
+  # The neighbor cells
+  attr_accessor :north, :east, :south, :west
+  
+  def neighbors
+    [north, east, south, west].compact
+  end
+end

data/lib/amaze/distances.rb

@@ -0,0 +1,53 @@
+
+class Amaze::Distances
+  
+  def initialize root
+    @root = root
+    @cells = {}
+    @cells[root] = 0
+  end
+  
+  def [] cell
+    @cells[cell]
+  end
+  
+  def []= cell, distance
+    @cells[cell] = distance
+  end
+  
+  def cells
+    @cells.keys
+  end
+  
+  def path_to goal
+    current = goal
+    breadcrumbs = Amaze::Distances.new @root
+    breadcrumbs[current] = @cells[current]
+    
+    until current == @root
+      current.links.each do |neighbor|
+        if @cells[neighbor] < @cells[current]
+          breadcrumbs[neighbor] = @cells[neighbor]
+          current = neighbor
+          break
+        end 
+      end
+    end
+    
+    breadcrumbs
+  end
+  
+  def max
+    max_cell = @root
+    max_distance = 0
+    
+    @cells.each do |cell, distance|
+      if distance > max_distance
+        max_cell = cell
+        max_distance = distance
+      end
+    end
+    
+    [max_cell, max_distance]
+  end
+end

data/lib/amaze/factory.rb

@@ -0,0 +1,153 @@
+
+require 'gradient'
+
+class Amaze::Factory
+
+  # All known maze types
+  def self.types
+    %i( delta ortho sigma upsilon polar )
+  end
+  
+  # The type of the grid
+  attr_reader :type
+  
+  def initialize type
+    raise "#{type} maze is not supported" unless self.class.types.include? type
+    @type = type
+  end
+  
+  def create_grid *args
+    Amaze::Grid.const_get(type.to_s.capitalize).new *args
+  end
+
+  def create_masked_grid file
+    klass = Amaze::Grid.const_get(type.to_s.capitalize)
+    klass.prepend Amaze::MaskedGrid
+    klass.new create_mask(file)
+  end
+  
+  def create_mask file
+    case File.extname file
+    when '.txt'
+      Amaze::Mask.from_txt file
+    when '.png'
+      Amaze::Mask.from_png file
+    else
+      raise "Mask file of type #{File.extname(file)} is not supported."
+    end
+  end
+  
+  # All known shapes
+  def self.shapes
+    %i( triangle diamond hexagon star )
+  end
+
+  def create_shaped_grid shape, *args
+    klass = Amaze::Grid.const_get(type.to_s.capitalize)
+    klass.prepend Amaze::MaskedGrid
+    klass.new Amaze::Shape.const_get(shape.to_s.capitalize).new(args.first).create_mask
+  end
+  
+  def create_ascii_formatter *args
+    Amaze::Formatter::ASCII.const_get(type.to_s.capitalize).new *args
+  end
+
+  def create_image_formatter *args
+    Amaze::Formatter::Image.const_get(type.to_s.capitalize).new *args
+  end
+
+  # All known algorithms
+  def self.algorithms
+    %i( bt sw ab gt1 gt2 gt3 gt4 w hk rb1 rb2 )
+  end
+  
+  def create_algorithm algorithm
+    raise "#{algorithm} is not supported" unless self.class.algorithms.include? algorithm
+    
+    # Alogrithms for all mazes
+    select = {
+      ab:  Amaze::Algorithm::AldousBorder,
+      gt1: Amaze::Algorithm::GrowingTree,
+      gt2: Amaze::Algorithm::GrowingTree,
+      gt3: Amaze::Algorithm::GrowingTree,
+      gt4: Amaze::Algorithm::GrowingTree,
+      w:   Amaze::Algorithm::Wilson,
+      hk:  Amaze::Algorithm::HuntAndKill,
+      rb1: Amaze::Algorithm::RecursiveBacktracker,
+      rb2: Amaze::Algorithm::RecursiveBacktracker,
+    }
+    
+    # Algorithms only for ortho mazes
+    select.merge!(
+      bt: Amaze::Algorithm::BinaryTree,
+      sw: Amaze::Algorithm::Sidewinder
+    ) if type == :ortho
+    
+    raise "Alogrithm not supported on #{type} maze." unless select[algorithm]
+    instance = select[algorithm].new
+
+    case algorithm
+    when :gt1
+      instance.configure "last from list", proc {|active| active.last }
+    when :gt2
+      instance.configure "random from list", proc {|active| active.sample }
+    when :gt3
+      instance.configure "last/random 1/1 from list", proc {|active| (rand(2) > 0) ? active.last : active.sample }
+    when :gt4
+      instance.configure "last/random 2/1 from list", proc {|active| (rand(3) > 0) ? active.last : active.sample }
+    when :rb1
+      instance.configure :stack
+    when :rb2
+      instance.configure :recursion
+    end
+    
+    instance 
+  end
+  
+  def self.gradient_maps
+    %i( red green blue monochrome cold warm gold )
+  end
+  
+  def gradient_map name=:green
+    { red:
+        Gradient::Map.new(
+          Gradient::Point.new(0, Color::RGB.new( 95,   0,   0), 1.0), # dark red
+          Gradient::Point.new(1, Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      green:
+        Gradient::Map.new(
+          Gradient::Point.new(0, Color::RGB.new(  0,  95,   0), 1.0), # dark green
+          Gradient::Point.new(1, Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      blue:
+        Gradient::Map.new(
+          Gradient::Point.new(0, Color::RGB.new(  0,   0,  95), 1.0), # dark blue
+          Gradient::Point.new(1, Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      monochrome: 
+        Gradient::Map.new(
+          Gradient::Point.new(0, Color::RGB.new(  0,   0,   0), 1.0), # black
+          Gradient::Point.new(1, Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      cold: 
+        Gradient::Map.new(
+          Gradient::Point.new(0,    Color::RGB.new(  0,   0,  95), 1.0), # blue
+          Gradient::Point.new(0.65, Color::RGB.new(  0, 191, 255), 1.0), # cyan
+          Gradient::Point.new(1,    Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      warm: 
+        Gradient::Map.new(
+          Gradient::Point.new(0,    Color::RGB.new( 95,   0,   0), 1.0), # dark red
+          Gradient::Point.new(0.65, Color::RGB.new(255, 191,   0), 1.0), # yellow
+          Gradient::Point.new(1,    Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+      gold:
+        Gradient::Map.new(
+          Gradient::Point.new(0,    Color::RGB.new(127,   0,   0), 1.0), # dark red
+          Gradient::Point.new(0.5,  Color::RGB.new(255, 127,   0), 1.0), # light red yellow
+          Gradient::Point.new(0.75, Color::RGB.new(255, 255,   0), 1.0), # yellow
+          Gradient::Point.new(1,    Color::RGB.new(255, 255, 255), 1.0), # white
+        ),
+    }[name]
+  end
+end