hanoi-jane 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d7f114e32d1a1e8f3a9f59cf07c86c0d68c9a17
-  data.tar.gz: b78e6dbd9b7deffc063e60049e22888183742a7f
+  metadata.gz: c8a1d92da6a843d6068462542eb6728d80995eed
+  data.tar.gz: dbac7d2f1d65726fc56aad01a1653f8818915e22
 SHA512:
-  metadata.gz: 695210a096216a3c91bdf43e8ff86cc3130cf8657bf5a6ef66c6f1da2ce17ca0bc26cb9f1420ba02c3e5d1c21ee03610afa9f9140a0919529ae64959b42111d4
-  data.tar.gz: bc72d1599263f725be624fb56c4d7ee6e488d44658f6627a2620a40b1e1eb062b14ce0048ababc968439abbd329c0c9e5a0c7b298a49db5a3c7cee693e703ee7
+  metadata.gz: 49ed23e2f5f6abe0f6585cee6e023098ddbff0cbf70ad90c09fe499f2483264a3cce98d2046dc8324a6e219fdbe7b71931f6800856d1877f2864585a60f46e09
+  data.tar.gz: e2b44701f251b4c172c8f01880878c8f61a789b75e3d1526e1f006846a05c0dcafd4bd22f99af214f1f3de8e8d5e0768f31b24b330e1d81b96d5ce2c09463561

data/README.md

@@ -45,15 +45,15 @@ end
 which will give you:
 
 ```ruby
-{:stacks=>[[1, 0], [], []], :moves=>0, :moved=>nil, :ternary=>'00'}
-{:stacks=>[[1], [0], []], :moves=>1, :moved=>0, :ternary=>'01'}
-{:stacks=>[[1], [], [0]], :moves=>2, :moved=>0, :ternary=>'02'}
-{:stacks=>[[], [1], [0]], :moves=>3, :moved=>1, :ternary=>'10'}
-{:stacks=>[[], [1, 0], []], :moves=>4, :moved=>0, :ternary=>'11'}
-{:stacks=>[[0], [1], []], :moves=>5, :moved=>0, :ternary=>'12'}
-{:stacks=>[[0], [], [1]], :moves=>6, :moved=>1, :ternary=>'20'}
-{:stacks=>[[], [0], [1]], :moves=>7, :moved=>0, :ternary=>'21'}
-{:stacks=>[[], [], [1, 0]], :moves=>8, :moved=>0, :ternary=>'22'}
+{:stacks=>[[1, 0], [], []], :moves=>0, :moved=>{:disc=>nil, :from=>nil, :to=>nil}, :ternary=>"00"}
+{:stacks=>[[1], [0], []], :moves=>1, :moved=>{:disc=>0, :from=>0, :to=>1}, :ternary=>"01"}
+{:stacks=>[[1], [], [0]], :moves=>2, :moved=>{:disc=>0, :from=>1, :to=>2}, :ternary=>"02"}
+{:stacks=>[[], [1], [0]], :moves=>3, :moved=>{:disc=>1, :from=>0, :to=>1}, :ternary=>"10"}
+{:stacks=>[[], [1, 0], []], :moves=>4, :moved=>{:disc=>0, :from=>2, :to=>1}, :ternary=>"11"}
+{:stacks=>[[0], [1], []], :moves=>5, :moved=>{:disc=>0, :from=>1, :to=>0}, :ternary=>"12"}
+{:stacks=>[[0], [], [1]], :moves=>6, :moved=>{:disc=>1, :from=>1, :to=>2}, :ternary=>"20"}
+{:stacks=>[[], [0], [1]], :moves=>7, :moved=>{:disc=>0, :from=>0, :to=>1}, :ternary=>"21"}
+{:stacks=>[[], [], [1, 0]], :moves=>8, :moved=>{:disc=>0, :from=>1, :to=>2}, :ternary=>"22"}
 ```
 where `moved` is the disc that was moved last
 
@@ -61,8 +61,8 @@ where `moved` is the disc that was moved last
 
 In order to over-engineer this, I've wrapped a [very thin Flask app](https://github.com/pikesley/pHAT-REST) around the [MicroDot pHAT](https://shop.pimoroni.com/products/microdot-phat). Try
 
-    hanoi phat --phat <address_of_your_pi> --constrained
+    hanoi phat --phat <address_of_your_pi> --interval 0.1
 
-to watch this all [play out on the pHAT](https://www.youtube.com/watch?v=PAQY5XtdNO8):
+to watch this all [play out on the pHAT](https://www.youtube.com/watch?v=LT3HNsVxhM8):
 
-[![Video](https://i.imgur.com/QILZYgx.png)](https://www.youtube.com/watch?v=PAQY5XtdNO8)
+[![Screenshot](https://i.imgur.com/yrK3isK.png)](https://www.youtube.com/watch?v=LT3HNsVxhM8)

data/TODO.md

@@ -0,0 +1 @@
+Can I conditionally include a module at constructor time? To e.g. pull in the ConstrainedTowers-specific search methods

data/config/config.yml

@@ -0,0 +1,30 @@
+chars:
+  regular:
+    space: ' '
+    disc: 'o'
+    pole: '|'
+    vert_divider: '|'
+    horiz_divider: '-'
+
+  fancy:
+    space: ' '
+    disc: '🎾'
+    pole: '💈'
+    vert_divider: '🔺'
+    horiz_divider: '🔻'
+
+digits:
+  '0':
+    - [1, 1, 1]
+    - [1, 0, 1]
+    - [1, 1, 1]
+
+  '1':
+    - [0, 1, 0]
+    - [0, 1, 0]
+    - [0, 1, 0]
+
+  '2':
+    - [1, 1, 0]
+    - [0, 1, 0]
+    - [0, 1, 1]

data/lib/hanoi/jane.rb

@@ -1,21 +1,39 @@
+require 'singleton'
+require 'yaml'
+require 'ostruct'
+
 require 'thor'
 require 'httparty'
 
 require 'hanoi/jane/version'
 
-require 'hanoi/jane/towers'
-require 'hanoi/jane/constrained_towers'
-require 'hanoi/jane/animation'
+require 'hanoi/jane/config'
+
+require 'hanoi/jane/towers/stack_finders'
+require 'hanoi/jane/towers/towers'
+require 'hanoi/jane/towers/constrained_towers'
+require 'hanoi/jane/towers/animated_towers'
+
+require 'hanoi/jane/animation/animation'
+require 'hanoi/jane/animation/lifter'
+require 'hanoi/jane/animation/dropper'
+require 'hanoi/jane/animation/padded_stacks'
 
 require 'hanoi/jane/formatters/matrix'
 require 'hanoi/jane/formatters/console'
 
 module Hanoi
   module Jane
-    def self.hit_phat towers, phat
+    def self.hit_phat stacks, value, phat
+      matrix = Formatters::Matrix.new do |m|
+        m.stacks = stacks
+        m.digits = value
+      end
+      matrix.populate
+
       url = "http://#{phat}/lights"
       payload = {
-        matrix: towers.matrix
+        matrix: matrix
       }
       headers = {
         'Content-Type' => 'application/json',

data/lib/hanoi/jane/animation/animation.rb

@@ -0,0 +1,35 @@
+module Hanoi
+  module Jane
+    class Animation
+      include Enumerable
+
+      attr_accessor :stacks, :disc, :from, :to, :height
+
+      def initialize
+        @stacks = [[0]]
+        @disc = 0
+        @from = 0
+        @to = 1
+        @height = 7
+
+        yield self if block_given?
+
+        @stacks = PaddedStacks.new @stacks, @height
+        @lifter = Lifter.new @stacks[@from]
+        @dropper = Dropper.new @stacks[@to], @disc
+      end
+
+      def each
+        @lifter.each do |state|
+          @stacks[@from] = state.to_a
+          yield self
+        end
+
+        @dropper.each do |state|
+          @stacks[@to] = state.to_a
+          yield self
+        end
+      end
+    end
+  end
+end

data/lib/hanoi/jane/animation/dropper.rb

@@ -0,0 +1,36 @@
+module Hanoi
+  module Jane
+    class Dropper < Array
+      def initialize stack, item
+        stack.map { |i| self.push i }
+        @item = item
+      end
+
+      def drop
+        pos = Dropper.position self, @item
+        self[pos] = @item
+
+        unless pos >= self.length - 1
+          self[pos + 1] = nil
+        end
+      end
+
+      def dropped
+        (self[(Dropper.position self, @item) - 1] || self[(Dropper.position self, @item)]) || (Dropper.position self, @item) == 0
+      end
+
+      def each 
+        until dropped
+          drop
+          yield self
+        end
+      end
+
+      def Dropper.position stack, item
+        pos = stack.index item
+        return stack.length - 1 unless pos
+        pos - 1
+      end
+    end
+  end
+end

data/lib/hanoi/jane/animation/lifter.rb

@@ -0,0 +1,46 @@
+module Hanoi
+  module Jane
+    class Lifter < Array
+      attr_reader :lifted
+
+      def initialize stack
+        stack.map { |i| self.push i }
+
+        @lifted = false
+      end
+
+      def lift
+        start = Lifter.position self
+
+        item = self[start]
+        self[start] = nil
+
+        next_pos = start + 1
+        if next_pos >= self.length
+          @lifted = true
+        else
+          self[next_pos] = item
+        end
+      end
+
+      def each
+        until @lifted
+          lift
+          yield self
+        end
+      end
+
+      def Lifter.position stack
+        pos = nil
+        stack.reverse.each_with_index do |item, index|
+          if item
+            pos = index
+            break
+          end
+        end
+
+        stack.length - 1 - pos
+      end
+    end
+  end
+end

data/lib/hanoi/jane/animation/padded_stacks.rb

@@ -0,0 +1,15 @@
+module Hanoi
+  module Jane
+    class PaddedStacks < Array
+      def initialize stacks, height = 7
+        stacks.clone.each do |s|
+          self.push PaddedStacks.pad s.clone, height
+        end
+      end
+
+      def PaddedStacks.pad stack, height
+        stack + Array.new(height - stack.length)
+      end
+    end
+  end
+end

data/lib/hanoi/jane/cli.rb

@@ -12,73 +12,58 @@ module Hanoi
       desc 'phat', "Solve the towers against the pHAT's webserver"
       option :phat, type: :string, required: true
       option :constrained, type: :boolean
-      option :interval, type: :numeric, default: 0.3
-      option :animated, type: :boolean, default: false
+      option :interval, type: :numeric, default: 0.1
 
       def phat
-        towers = Towers.new 5
-        if options[:constrained]
-          towers = ConstrainedTowers.new 5
+        at = AnimatedTowers.new do |a|
+          a.towers = ConstrainedTowers
+          a.discs = 5
+          a.height = 7
         end
 
-        towers.animated = options[:animated]
-
-        towers.each do |state|
-          if state.animation
-            state.animation.each do |frame|
-              Hanoi::Jane.hit_phat frame, options[:phat]
-              sleep options[:interval] * 0.1
-            end
+        at.each do |frame|
+          Hanoi::Jane.hit_phat frame.stacks, frame.value, options[:phat]
+          interval = options[:interval]
+          if frame.type == :tween
+            interval = interval * 0.1
           end
-
-          Hanoi::Jane.hit_phat towers, options[:phat]
-          sleep options[:interval]
+          sleep interval
         end
       end
 
       desc 'console', 'Solve the towers on the console'
-      option :discs, type: :numeric, default: 3, minimum: 1
-      option :constrained, type: :boolean
+      option :discs, type: :numeric, default: 3
+      option :constrained, type: :boolean, default: true
+      option :interval, type: :numeric, default: 0.5
+      option :height, type: :numeric, default: 2
       option :fancy, type: :boolean, default: false
-      option :animated, type: :boolean, default: false
-      option :delay, type: :numeric, default: 0.2
 
       def console
-        if options[:discs] < 1
-          puts "Solving for %d discs makes no sense" % options[:discs]
-          exit 1
+        at = AnimatedTowers.new do |a|
+          a.towers = options[:constrained] ? ConstrainedTowers : Towers
+          a.discs = options[:discs]
+          a.height = options[:discs] + options[:height]
         end
 
-        towers = Towers.new options[:discs]
+        at.each do |frame|
+          system('clear')
 
-        if options[:constrained]
-          towers = ConstrainedTowers.new options[:discs]
-        end
+          c = Formatters::Console.new do |c|
+            c.stacks = frame.stacks
+            c.fancy = options[:fancy]
+          end
 
-        towers.fancy = options[:fancy]
-        towers.animated = options[:animated]
+          puts frame.value
+          puts c
 
-        towers.each do |state|
-          if state.animation
-            state.animation.each do |frame|
-              system('clear')
-              s = options[:fancy] ? (Formatters::Console.fancify state.rebased) : state.rebased
-              puts s
-              puts
-              puts frame
-              sleep options[:delay] * 0.2
-            end
+          interval = options[:interval]
+          if frame.type == :tween
+            interval = interval * 0.1
           end
-
-          system('clear')
-          s = options[:fancy] ? (Formatters::Console.fancify state.rebased) : state.rebased
-          puts s
-          puts
-          puts state.console
-          sleep options[:delay]
+          sleep interval
         end
 
-        puts '%d moves to solve for %d discs' % [towers.total, options[:discs]]
+        puts '%d moves to solve for %d discs' % [at.towers.total, at.discs]
       end
     end
   end

data/lib/hanoi/jane/config.rb

@@ -0,0 +1,25 @@
+module Hanoi
+  module Jane
+    class Config
+      include Singleton
+
+      def initialize
+        reset!
+      end
+
+      def reset! # testing a singleton is hard
+        @config = OpenStruct.new fetch_yaml 'config'
+      end
+
+      def config
+        @config
+      end
+
+      private
+
+      def fetch_yaml file
+        YAML.load(File.open(File.join(File.dirname(__FILE__), '..', '..', '..', 'config/%s.yml' % file)))
+      end
+    end
+  end
+end

data/lib/hanoi/jane/formatters/console.rb

@@ -2,65 +2,68 @@ module Hanoi
   module Jane
     module Formatters
       class Console
-        CHARS = {
-          space: ' ',
-          disc: 'o',
-          pole: '|',
-          vert_divider: '|',
-          horiz_divider: '-'
-        }
-
-        FANCY_CHARS = {
-          space: ' ',
-          disc: '🎾',
-          pole: '💈',
-          vert_divider: '🔺',
-          horiz_divider: '🔻'
-        }
-
-        def initialize discs, stacks, fancy = false
-          @discs = discs
-          @stacks = stacks.clone.map { |s| s.clone }
-          @@chars = fancy ? FANCY_CHARS : CHARS
+        attr_accessor :stacks, :fancy
+
+        def initialize
+          @fancy = false
+
+          yield self if block_given?
         end
 
         def to_s
-          s = ''
-          joiner = @@chars[:space]
+          (Console.populate stacks, @fancy).map { |r| r.join '' }.join "\n"
+        end
 
-          (Console.rotate @stacks.map { |s| (Console.pad s, @discs).reverse }).each_with_index do |stack, i|
-            joiner = @@chars[:vert_divider] if i == @discs
+        def Console.assemble stacks
+          a = []
+          (Console.rotate stacks).each_with_index do |r, index|
+            divided = (index + 1) == stacks.first.length ? true : false
+            a.push Console.row r, widest: Console.biggest(stacks), divided: divided
+          end
 
-            s += "%s%s%s\n" % [
-              joiner,
-              stack.map { |s| Console.make_disc s, (Console.scale @discs) }.join(joiner),
-              joiner
-            ]
+          a.push [:horiz_divider] * a[0].length
 
-          end
+          a
+        end
 
-          s += "%s\n" % [@@chars[:horiz_divider] * (4 + (Console.scale @discs) * 3)]
+        def Console.populate stacks, fancy = false
+          charset = fancy ? 'fancy' : 'regular'
+          (Console.assemble stacks).map do
+            |r| r.map do |c|
+              Config.instance.config.chars[charset][c.to_s]
+            end
+          end
         end
 
-        def Console.pad array, length
-          Array.new(length - array.length) + array.reverse
+        def Console.biggest stacks
+          stacks.map { |s| s.compact.max }.compact.max
         end
 
-        def Console.make_disc width, space
-          char = @@chars[:disc]
-          unless width
-            width = 0
-            char = @@chars[:pole]
+        def Console.disc size, width
+          return [:space] * Console.scale(width) unless size
+          content = Console.scale size
+          gap = (Console.scale(width) - content) / 2
+
+          output = [:disc] * content
+
+          gap.times do
+            [:unshift, :push].each do |method|
+              output.send(method, :space)
+            end
           end
 
-          count = Console.scale width
-          padding = (space - count) / 2
+          output
+        end
+
+        def Console.row starter, widest:, spacing: 1, divided: false
+          filler = [:space] * spacing
+          filler = [:vert_divider] if divided
 
-          '%s%s%s' % [
-            @@chars[:space] * padding,
-            char * count,
-            @@chars[:space] * padding
-          ]
+          starter.map { |d|
+            Console.disc d, widest
+          }.flat_map { |d|
+            [d, filler]
+          }.unshift(filler).flatten
         end
 
         def Console.scale size
@@ -70,11 +73,6 @@ module Hanoi
         def Console.rotate stacks
           stacks.map { |s| s.clone }.transpose.reverse
         end
-
-        def Console.fancify number
-          fancy_digits = '012'
-          number.chars.map { |d| fancy_digits[d] }.join ' '
-        end
       end
     end
   end

data/lib/hanoi/jane/formatters/matrix.rb

@@ -2,73 +2,86 @@ module Hanoi
   module Jane
     module Formatters
       class Matrix < Array
-        def initialize towers
-          @stacks = towers.stacks
-          @digits = towers.rebased
+        attr_accessor :stacks
+        attr_reader   :digits, :bit_offset
 
-          populate
+        def initialize
+          @digits = '0'
+          @stacks = [[]]
+
+          @bit_offset = 24
+          @bit_side = :right
+          @valid_digits = Config.instance.config.digits
+
+          yield self if block_given?
+
+          #populate
         end
 
-        def stacks= stacks
-          @stacks = stacks
-          populate
+        def digits= digits
+          if digits.chars.reject { |d| @valid_digits.keys.include? d }.length > 0
+            raise MatrixException.new '%s is not a valid value for digits' % digits
+          end
+
+          if digits.length > 5
+            raise MatrixException.new '%s is longer than 5 chars' % digits
+          end
+
+          @digits = digits
         end
 
-        def populate
+        def wipe
           7.times do |i|
             self[i] = [0] * 45
           end
+        end
+
+        def draw_disc disc, height = 0, offset = 0
+          if disc
+            (disc + 1).times do |i|
+              self[6 - height][i + offset + (Matrix.shim disc)] = 1
+            end
+          end
+        end
+
+        def draw_stack stack, offset = 0
+          height = 0
+          stack.each do |disc|
+            draw_disc disc, height, offset
+            height += 1
+          end
+        end
 
+        def populate
+          wipe
+          draw_stacks
+          draw_digits
+        end
+
+        def draw_stacks
           offset = 0
           @stacks.each do |stack|
-            total = 0
-            stack.each do |disc|
-              if disc
-                shim = ((5 - (disc + 1)) / 2).round
-                (disc + 1).times do |i|
-                  self[6 - total][i + offset + shim] = 1
-                end
-              end
-              total += 1
-            end
+            draw_stack stack, offset
             offset += 8
           end
+        end
 
-          @bit_offset = 24
-          @bit_side = :right
+        def draw_digits
           @digits.chars.each do |bit|
             digit bit
+            @bit_side = realign @bit_side
+          end
+        end
 
-            if @bit_side == :right
-              @bit_side = :left
-              @bit_offset += 8
-            else
-              @bit_side = :right
-            end
+        def realign side
+          if side == :right
+            @bit_offset += 8
+            return :left
           end
+          :right
         end
 
         def digit value
-          digits = {
-            0 => [
-              [1, 1, 1],
-              [1, 0, 1],
-              [1, 1, 1]
-            ],
-
-            1 => [
-              [0, 1, 0],
-              [0, 1, 0],
-              [0, 1, 0]
-            ],
-
-            2 => [
-              [1, 1, 0],
-              [0, 1, 0],
-              [0, 1, 1]
-            ]
-          }
-
           @column = @bit_offset
           @row = 0
           if @bit_side == :right
@@ -76,17 +89,28 @@ module Hanoi
             @row = 4
           end
 
-          insert digits[value.to_i]
-
+          insert value, @row, @column
         end
 
-        def insert grid
+        def insert value, row = 0, column = 0
           3.times do |i|
             3.times do |j|
-              self[@row + i][@column + j] = grid[i][j]
+              self[row + i][column + j] = @valid_digits[value][i][j]
             end
           end
         end
+
+        def Matrix.shim size
+          ((5 - (size + 1)) / 2).round
+        end
+      end
+
+      class MatrixException < Exception
+        attr_reader :text
+
+        def initialize text
+          @text = text
+        end
       end
     end
   end

data/lib/hanoi/jane/towers/animated_towers.rb

@@ -0,0 +1,60 @@
+module Hanoi
+  module Jane
+    class AnimatedTowers
+      include Enumerable
+
+      attr_accessor :towers, :discs, :height
+
+      def initialize
+        yield self if block_given?
+
+        if @discs > @height
+          raise HanoiException.new 'number_of_discs (%d) > height (%d)' % [@height, @discs]
+        end
+
+        @towers = @towers.new @discs
+      end
+
+      def each
+        until @towers.solved
+          stacks = PaddedStacks.new @towers.stacks, @height
+          value = @towers.rebased
+          @towers.move
+          yield Frame.new stacks, value, :key
+
+          @anim = Animation.new do |a|
+            a.stacks = stacks
+            a.disc = @towers.disc
+            a.from = @towers.from
+            a.to = @towers.to
+            a.height = @height
+          end
+
+          @anim.each do |frame|
+            yield Frame.new frame.stacks, @towers.rebased, :tween
+          end
+        end
+
+        yield Frame.new (PaddedStacks.new @towers.stacks, @height), @towers.rebased, :key
+      end
+    end
+
+    class Frame
+      attr_reader :stacks, :type, :value
+
+      def initialize stacks, value, type
+        @stacks = stacks
+        @value = value
+        @type = type
+      end
+    end
+
+    class HanoiException < Exception
+      attr_reader :text
+
+      def initialize text
+        @text = text
+      end
+    end
+  end
+end

data/lib/hanoi/jane/towers/constrained_towers.rb

@@ -0,0 +1,22 @@
+module Hanoi
+  module Jane
+    class ConstrainedTowers < Towers
+      extend ConstrainedStackFinder
+      
+      def initialize discs = 3
+        super
+        @base = 3
+      end
+
+      def ternary
+        rebased
+      end
+
+      def inspect
+        i = super
+        i[:ternary] = i.delete :binary
+        i
+      end
+    end
+  end
+end

data/lib/hanoi/jane/towers/stack_finders.rb

@@ -0,0 +1,36 @@
+module Hanoi
+  module Jane
+    module StackFinder
+      def find_stack stacks:, from:, disc:, total: nil
+        # if the next stack is empty, move there
+        if stacks[(from + 1) % 3] == []
+          return (from + 1) % 3
+        end
+
+        # if the next stack has a smaller top disc than our disc, go one more over
+        if stacks[(from + 1) % 3][-1] < disc
+          return (from + 2) % 3
+        end
+
+        # default to the next one
+        return (from + 1) % 3
+      end
+    end
+
+    module ConstrainedStackFinder
+      def find_stack stacks:, from:, disc: nil, total:
+        # if we're in the middle
+        if from == 1
+          # we always move to the right on an even total
+          if total % 2 == 0
+            return 2
+          else
+            return 0
+          end
+        end
+        # otherwise we're at the edges and can only move to the middle
+        1
+      end
+    end
+  end
+end

data/lib/hanoi/jane/towers/towers.rb

@@ -0,0 +1,114 @@
+module Hanoi
+  module Jane
+    class Towers
+      extend StackFinder
+
+      attr_reader   :stacks, :total, :base, :disc, :from, :to
+      attr_accessor :discs
+
+      def initialize discs = 3
+        @discs = discs
+        @total = 0
+        @base = 2
+        @stacks = Towers.starter_stacks @discs
+
+        yield self if block_given?
+      end
+
+      def discs= discs
+        @discs = discs
+        @stacks = Towers.starter_stacks @discs
+      end
+
+      def move
+        before = binary
+        @total += 1
+        after = binary
+
+        @disc = Towers.diff before, after
+
+        @from = Towers.find_disc @stacks, @disc
+        @to = self.class.find_stack stacks: @stacks, from: @from, disc: @disc, total: @total
+        @stacks[@to].push @stacks[@from].pop
+      end
+
+      def solved
+        rebased.chars.all? { |digit| digit.to_i == @base - 1 }
+      end
+
+      def inspect
+        {
+          stacks: @stacks,
+          moves: @total,
+          binary: rebased,
+          moved: {
+            disc: @disc,
+            from: @from,
+            to: @to
+          }
+        }
+      end
+
+      def each
+        yield self if @total == 0
+        until solved
+          move
+          yield self
+        end
+      end
+
+      def to_s
+        s = ''
+        @stacks.each do |stack|
+          s += stack.to_s
+          s += "\n"
+        end
+        s += '---'
+
+        s
+      end
+
+      def binary
+        rebased
+      end
+
+      def rebased
+        Towers.rebase @total, @base, @discs
+      end
+
+      private
+
+      def Towers.starter_stacks discs
+        [(0...discs).to_a.reverse, [], []]
+      end
+
+      def Towers.diff this, that
+        this.chars.reverse.each_with_index do |bit, index|
+          if bit < that.chars.reverse[index]
+          return index
+          end
+        end
+      end
+
+      def Towers.rebase value, base, width
+        '%0*d' % [width, value.to_s(base)]
+      end
+
+      def Towers.find_disc stacks, disc
+        stacks.each_with_index do |stack, index|
+          return index if stack.index disc
+        end
+
+        raise SearchException.new '%s not found in stacks' % disc
+      end
+    end
+
+    class SearchException < Exception
+      attr_reader :text
+
+      def initialize text
+        @text = text
+      end
+    end
+  end
+end

data/lib/hanoi/jane/version.rb

@@ -1,5 +1,5 @@
 module Hanoi
   module Jane
-    VERSION = '0.2.5'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanoi-jane
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - pikesley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-14 00:00:00.000000000 Z
+date: 2018-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,17 +141,25 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- TODO.md
 - bin/console
 - bin/hanoi
 - bin/setup
+- config/config.yml
 - hanoi-jane.gemspec
 - lib/hanoi/jane.rb
-- lib/hanoi/jane/animation.rb
+- lib/hanoi/jane/animation/animation.rb
+- lib/hanoi/jane/animation/dropper.rb
+- lib/hanoi/jane/animation/lifter.rb
+- lib/hanoi/jane/animation/padded_stacks.rb
 - lib/hanoi/jane/cli.rb
-- lib/hanoi/jane/constrained_towers.rb
+- lib/hanoi/jane/config.rb
 - lib/hanoi/jane/formatters/console.rb
 - lib/hanoi/jane/formatters/matrix.rb
-- lib/hanoi/jane/towers.rb
+- lib/hanoi/jane/towers/animated_towers.rb
+- lib/hanoi/jane/towers/constrained_towers.rb
+- lib/hanoi/jane/towers/stack_finders.rb
+- lib/hanoi/jane/towers/towers.rb
 - lib/hanoi/jane/version.rb
 homepage: http://sam.pikesley.org/projects/hanoi-jane/
 licenses:

data/lib/hanoi/jane/animation.rb

@@ -1,79 +0,0 @@
-module Hanoi
-  module Jane
-    class Animation
-      include Enumerable
-
-      attr_reader :stacks
-
-      def initialize towers
-        @towers = towers
-        @height = towers.discs
-        @stacks = Animation.pad towers.old_stacks, @height
-        @disc = towers.disc
-        @source = towers.source
-        @destination = towers.sink
-        @fancy = towers.fancy
-
-        @lift = true
-        @drop = false
-        @done = false
-      end
-
-      def animate
-        @drop = true unless @lift
-        if @lift
-          stack = @stacks[@source]
-          @position = stack.index @disc
-          stack[@position] = nil
-
-          if @position + 1 >= @height
-            @lift = false
-          else
-            stack[@position + 1] = @disc
-          end
-
-          @stacks[@source] = stack
-        end
-
-        if @drop
-          stack = @stacks[@destination]
-          @position = -1 unless @position
-
-          stack[@position] = @disc
-          stack[(stack.index @disc) + 1] = nil
-
-          @position -= 1
-
-          @stacks[@destination] = stack.take @height
-
-          if stack[@position] || @position == 0
-            @drop = false
-            @done = true
-          end
-        end
-      end
-
-      def to_s
-        (Formatters::Console.new @height, @stacks, @fancy).to_s
-      end
-
-      def matrix
-        m = Formatters::Matrix.new @towers
-        m.stacks = @stacks
-
-        m
-      end
-
-      def each
-        until @done
-          animate
-          yield self
-        end
-      end
-
-      def Animation.pad stacks, height
-        stacks.map { |stack| stack + Array.new(height - stack.length) }
-      end
-    end
-  end
-end

data/lib/hanoi/jane/constrained_towers.rb

@@ -1,36 +0,0 @@
-module Hanoi
-  module Jane
-    class ConstrainedTowers < Towers
-      def initialize discs
-        super
-        @base = 3
-      end
-
-      def ternary
-        rebased
-      end
-
-      def inspect
-        i = super
-        i[:ternary] = i.delete :binary
-        i
-      end
-
-      private
-
-      def find_stack
-        # if we're in the middle
-        if @source == 1
-          # we always move to the right on an even total
-          if @total % 2 == 0
-            return 2
-          else
-            return 0
-          end
-        end
-        # otherwise we're at the edges and can only move to the middle
-        1
-      end
-    end
-  end
-end

data/lib/hanoi/jane/towers.rb

@@ -1,122 +0,0 @@
-module Hanoi
-  module Jane
-    class Towers
-      include Enumerable
-
-      attr_reader :total, :stacks, :discs, :old_stacks, :disc, :source, :sink
-      attr_accessor :fancy, :animated, :animation
-
-      def initialize discs
-        @discs = discs
-        @total = 0
-        @base = 2
-        @stacks = [(0...discs).to_a.reverse, [], []]
-        @fancy = false
-        @animated = false
-      end
-
-      def move
-        @old_stacks = @stacks.clone.map { |s| s.clone }
-
-        diff
-        @source = find_disc
-        @sink = find_stack
-        @stacks[@sink].push @stacks[@source].pop
-
-        if @animated
-          @animation = Animation.new self
-        end
-      end
-
-      def solved
-        rebased.chars.all? { |digit| digit.to_i == @base - 1 }
-      end
-
-      def matrix
-        Formatters::Matrix.new self
-      end
-
-      def console
-        (Formatters::Console.new @discs, @stacks, @fancy).to_s
-      end
-
-      def inspect
-        {
-          stacks: @stacks,
-          moves: @total,
-          binary: rebased,
-          moved: {
-            disc: @disc,
-            from: @source,
-            to: @sink
-          }
-        }
-      end
-
-      def each
-        yield self if @total == 0
-        until solved
-          move
-          yield self
-        end
-      end
-
-      def to_s
-        s = ''
-        @stacks.each do |stack|
-          s += stack.to_s
-          s += "\n"
-        end
-        s += '---'
-
-        s
-      end
-
-      def binary
-        rebased
-      end
-
-      def rebased
-        Towers.rebase @total, @base, @discs
-      end
-
-      private
-
-      def find_disc
-        @stacks.each_with_index do |stack, index|
-          return index if stack.index @disc
-        end
-      end
-
-      def find_stack
-        # if the next stack is empty, move there
-        if @stacks[(@source + 1) % 3] == []
-          return (@source + 1) % 3
-        end
-
-        # if the next stack has a smaller top disc than our disc, go one more over
-        if @stacks[(@source + 1) % 3][-1] < @disc
-          return (@source + 2) % 3
-        end
-
-        # default to the next one
-        return (@source + 1) % 3
-      end
-
-      def diff
-        this = binary
-        @total += 1
-        that = binary
-        this.chars.reverse.each_with_index do |bit, index|
-          if bit < that.chars.reverse[index]
-            @disc = index
-          end
-        end
-      end
-
-      def Towers.rebase value, base, width
-        '%0*d' % [width, value.to_s(base)]
-      end
-    end
-  end
-end