astrid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5805f0aabcdedf0d3f848c806e3dcd84c11108ec
+  data.tar.gz: 8122dbbd6d0a2f111154e65f75eb36a5cd72eaca
+SHA512:
+  metadata.gz: 72ec33b083718e395523d2dc0a8c9e7268d24d05f1c27ffc5c845f4980e7d689226cf09a75b5f107d55b10d292fa24bda70640fd8468170ebb6366941fc89fcf
+  data.tar.gz: 1e17a34f968e762bace8f055800f443a209a452204bd4ffe69c7ebada0677c8a8b53643e999ffdddc9ad2d137307885970dbd00c3a33d95f484686312ece9c4d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in astrid.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem "rspec"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 JHawk
+
+MIT License
+
+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

@@ -0,0 +1,29 @@
+# Astrid
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'astrid'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install astrid
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/astrid/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/astrid.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'astrid/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "astrid"
+  spec.version       = Astrid::VERSION
+  spec.authors       = ["JHawk"]
+  spec.email         = ["josh.r.hawk@gmail.com"]
+  spec.summary       = %q{A Star in ruby.}
+  spec.description   = %q{A Star in ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/astrid/finders/a_star.rb

@@ -0,0 +1,195 @@
+require 'astrid/heuristics/manhattan'
+
+module Pathfinder
+  module Finders
+    class AStar
+
+      attr_accessor :allow_diagonal, :current_grid, :current_path
+
+      def initialize(opts={})
+        @allow_diagonal = opts[:allow_diagonal] || false
+        @heuristic = opts[:heuristic] || Heuristics::Manhattan
+#        @diagonal_movement = opts[:diagonal_movement]
+        @weight = opts[:weight] || 1;
+      end
+
+      def sanitize(node)
+        node
+      end
+
+      # look at
+      # https://github.com/qiao/PathFinding.js/blob/master/src/finders/AStarFinder.js
+      # A*
+      # requires x & y
+      # node = g, f, h, x, y, opened, walkable, closed, parent
+      #
+      # extract a grid class
+      # clearly not optomized at all!
+      def find_path(start_node, end_node, grid)
+        start_node = sanitize(start_node)
+        end_node = sanitize(end_node)
+        if grid.nil?
+          [start_node]
+        else
+          @current_grid = grid.clone
+          _max_x = grid[:max_x]
+          _max_y = grid[:max_y]
+
+          raise 'max_x & max_y required' unless _max_x && _max_y
+
+          _start_node = start_node.clone
+          _end_node = end_node.clone
+
+          heuristic = @heuristic.new(_end_node, @weight)
+
+          _start_node[:f] = 0   # sum of g and h
+          _start_node[:g] = 0   # steps to start node
+          _start_node[:h] = nil # steps to end node
+          _start_node[:opened] = true
+
+          # use heap or tree for better perf
+          open = []
+          open.push _start_node
+
+          while !open.empty? do
+            _current_node = open.pop
+
+            _current_node[:closed] = true
+            @current_grid[node_to_a(_current_node)] = _current_node
+
+            if node_to_a(_current_node) == node_to_a(_end_node)
+              return final_path(_current_node)
+            end
+
+            new_g = _current_node[:g] + 1
+
+            x = _current_node[:x]
+            y = _current_node[:y]
+
+            neighbors = []
+
+            neighbors << [x-1, y] if x > 0
+            neighbors << [x, y-1] if y > 0
+            neighbors << [x+1, y] if x < _max_x-1
+            neighbors << [x, y+1] if y < _max_y-1
+
+            _neighbors = neighbors.map do |position|
+              node = @current_grid[position]
+              if node.nil? || node[:walkable]
+                node ||= {}
+                @current_grid[position] = node.merge({
+                  x: position.first,
+                  y: position[1],
+                  closed: false,
+                  opened: false
+                })
+              end
+            end.compact
+
+            _neighbors.each do |neighbor|
+              if (!neighbor[:opened] || new_g < neighbor[:g])
+                neighbor[:g] = new_g
+                neighbor[:h] ||= heuristic.h(neighbor)
+                neighbor[:f] = neighbor[:g] + neighbor[:h]
+                neighbor[:parent] = node_to_a(_current_node)
+
+                if (!neighbor[:opened])
+                  open.push neighbor
+                  neighbor[:opened] = true
+                else
+                  # ???
+                  puts "got here some how!!!"
+                end
+              end
+            end
+
+            open.sort_by! {|i| [-i[:f], -i[:h]]}
+            # grid_p
+          end
+        end
+      end
+
+      def final_path(_end_node)
+        path = [_end_node]
+        _current_node = _end_node
+
+        while _current_node[:parent] do
+          parent_position = _current_node[:parent]
+          parent_node = @current_grid[parent_position]
+
+          path << parent_node
+          _current_node = parent_node
+        end
+
+        @current_path = path.reverse
+      end
+
+      def find_path_a(start_node, end_node, grid)
+        p = find_path(start_node, end_node, grid)
+        if p
+          p.map do |node|
+            node_to_a(node)
+          end
+        end
+      end
+
+      def find_path_a_with_time(start_node, end_node, grid)
+        result, time = find_path_a(start_node, end_node, grid)
+      end
+
+      def grid_from_s_map(str)
+        normalize = str.lines.reverse
+
+        max_x = normalize.map(&:length).max
+        max_y = normalize.length
+
+        y_idx = 0
+        normalize.inject({max_x: max_x, max_y: max_y}) do |grid, line|
+          line.each_char.each_with_index do |c, x_idx|
+            if c == '|' || c == '_'
+              grid.merge!(
+                [x_idx,y_idx] => { walkable: false}
+              )
+            end
+          end
+          y_idx += 1
+          grid
+        end
+      end
+
+      def visited_positions
+        @current_grid.select do |k,v|
+          k.is_a?(Array) && (v[:opened] || v[:closed])
+        end.map {|a| a[1]}
+      end
+
+      def grid_p
+        puts ""
+        puts "#"*80
+        s = ""
+        n = @current_grid[:max_y].to_s.size + 2
+        (-@current_grid[:max_y]..0).each do |y|
+          (0..@current_grid[:max_x]).each do |x|
+            node = @current_grid[[x,-y]]
+            if node
+              if node[:walkable].nil? || node[:walkable]
+                s << node[:f].to_s.rjust(n, " ")
+              else
+                s << "|".rjust(n, " ")
+              end
+            else
+              s << ''.rjust(n, '.')
+            end
+          end
+          s << "\n"
+        end
+        puts s
+      end
+
+      def node_to_a(node)
+        [node[:x], node[:y]]
+      end
+    end
+  end
+end
+

data/lib/astrid/heuristics/manhattan.rb

@@ -0,0 +1,17 @@
+module Pathfinder
+  module Heuristics
+    class Manhattan
+
+      def initialize(end_node, weight=1)
+        @end_x = end_node[:x]
+        @end_y = end_node[:y]
+        @weight = weight
+      end
+
+      def h(node, weight=@weight)
+        weight * ((node[:x] - @end_x).abs + (node[:y] - @end_y).abs)
+      end
+    end
+  end
+end
+

data/lib/astrid/version.rb

@@ -0,0 +1,3 @@
+module Astrid
+  VERSION = "0.0.1"
+end

data/lib/astrid.rb

@@ -0,0 +1,7 @@
+require "astrid/version"
+
+module Astrid
+  # Your code goes here...
+end
+
+require 'astrid/finders/a_star'

data/spec/astrid/finders/a_star_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+require 'astrid/finders/a_star'
+
+describe 'Pathfinder::Finders::AStar' do
+
+
+  let(:a_star) { Pathfinder::Finders::AStar.new }
+
+  describe "#grid" do
+    describe "#visited_positions" do
+      let(:closed) { {:x=>0, :y=>0, :f=>0, :g=>0, :h=>nil, :opened=>true, :closed=>true} }
+      let(:opened) { {:x=>0, :y=>0, :f=>0, :g=>0, :h=>nil, :opened=>true} }
+      let(:not_visited) { {:x=>0, :y=>0, :f=>0, :g=>0, :h=>nil} }
+
+      let(:grid) do
+        {
+          :max_x => 10,
+          :max_y => 10,
+
+          [0,0] => closed,
+          [0,1] => opened,
+          [0,2] => not_visited
+        }
+      end
+
+      before do
+        a_star.current_grid = grid
+      end
+
+      subject { a_star.visited_positions }
+
+      it { is_expected.to include(closed) }
+      it { is_expected.to include(opened) }
+      it { is_expected.not_to include(not_visited) }
+    end
+
+    describe "#grid_from_s_map" do
+      context "when | on map" do
+        subject do
+          a_star.grid_from_s_map(<<-G)
+.|.
+.|.
+          G
+        end
+
+        it 'makes the | not walkable' do
+          grid = subject
+
+          expect(grid[[1,0]][:walkable]).to be_falsey
+        end
+      end
+
+      context "when _ on map" do
+        subject do
+          a_star.grid_from_s_map(<<-G)
+._.
+._.
+          G
+        end
+
+        it 'makes the _ not walkable' do
+          grid = subject
+
+          expect(grid[[1,0]][:walkable]).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "#find_path" do
+    context 'timed' do
+      subject { a_star.find_path_a_with_time(position1, position2, grid) }
+
+      context 'origin to 100,100' do
+        let(:position1) { {x: 0, y: 0} }
+        let(:position2) { {x: 100, y: 100} }
+        let(:grid) { {max_x:10000, max_y:10000} }
+
+        it 'should not take too long' do
+          path = subject
+
+          expect(path).to include([0,0])
+          expect(path).to include([100,100])
+        end
+      end
+    end
+
+    context 'no diagonals' do
+      subject { a_star.find_path_a(position1, position2, grid) }
+
+      context 'origin to origin' do
+        let(:position1) { {x: 0, y: 0} }
+        let(:position2) { {x: 0, y: 0} }
+        let(:grid) { {max_x:10, max_y:10} }
+
+        it { is_expected.to eq([[0,0]]) }
+      end
+
+      context 'origin to 1,1' do
+        let(:position1) { {x: 0, y: 0} }
+        let(:position2) { {x: 1, y: 1} }
+
+        context "when grid is nil" do
+          let(:grid) { nil }
+
+          it { is_expected.to eq([[0,0]]) }
+        end
+
+        context "when grid contains start and end" do
+          let(:grid) { {max_x:2, max_y:2} }
+
+          it { is_expected.to eq([[0,0],[0,1],[1,1]]) }
+        end
+      end
+
+      context 'origin to 2,2' do
+        let(:position1) { {x: 0, y: 0} }
+        let(:position2) { {x: 2, y: 2} }
+        let(:grid) { {max_x:5, max_y:5} }
+
+        it { is_expected.to include([0,0]) }
+        it { is_expected.to include([2,2]) }
+
+        it 'has the correct length' do
+          path = subject
+
+          expect(path.length).to eq(5)
+        end
+      end
+
+      context 'unsolvable' do
+        context '1' do
+          let(:grid) {
+            a_star.grid_from_s_map(<<-G)
+....|......
+.1..|..2...
+....|......
+            G
+          }
+
+          let(:position1) { {x: 1, y: 1} }
+          let(:position2) { {x: 7, y: 1} }
+
+          it { is_expected.to be_nil }
+        end
+
+      end
+
+      context 'obstructed paths' do
+        context '1' do
+          let(:grid) {
+            a_star.grid_from_s_map(<<-G)
+........
+...........
+...........
+...........
+....|......
+.1..|..2...
+....|......
+..........
+...........
+            G
+          }
+
+          let(:position1) { {x: 1, y: 3} }
+          let(:position2) { {x: 7, y: 3} }
+
+          it { is_expected.to include([1,3]) }
+          it { is_expected.to include([7,3]) }
+
+          it { is_expected.not_to include([4,2]) }
+          it { is_expected.not_to include([4,3]) }
+          it { is_expected.not_to include([4,4]) }
+
+          it 'has the correct length' do
+            path = subject
+            expect(path.length).to eq(11)
+          end
+
+          it 'should only visit necessary positions' do
+            subject
+
+            expect(a_star.current_grid).not_to be_nil
+            expect(a_star.visited_positions.count).to eq(31)
+          end
+        end
+
+        context '2' do
+          let(:grid) {
+            a_star.grid_from_s_map(<<-G)
+......|.....
+.1....|.....
+......|.....
+......|.....
+......|..2..
+......|.....
+......|.....
+............
+............
+............
+............
+            G
+          }
+
+          let(:position1) { {x: 1, y: 10} }
+          let(:position2) { {x: 9, y: 6} }
+
+          it { is_expected.to include([1,10]) }
+          it { is_expected.to include([9,6]) }
+
+          it { is_expected.not_to include([6,4]) }
+          it { is_expected.not_to include([6,5]) }
+          it { is_expected.not_to include([6,6]) }
+          it { is_expected.not_to include([6,7]) }
+          it { is_expected.not_to include([6,8]) }
+          it { is_expected.not_to include([6,9]) }
+          it { is_expected.not_to include([6,10]) }
+          it { is_expected.not_to include([6,11]) }
+
+          it 'has the correct length' do
+            path = subject
+
+            expect(path.length).to eq(19)
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+RSpec.configure do |config|
+  config.order = "random"
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: astrid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- JHawk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Star in ruby.
+email:
+- josh.r.hawk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- astrid.gemspec
+- lib/astrid.rb
+- lib/astrid/finders/a_star.rb
+- lib/astrid/heuristics/manhattan.rb
+- lib/astrid/version.rb
+- spec/astrid/finders/a_star_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A Star in ruby.
+test_files:
+- spec/astrid/finders/a_star_spec.rb
+- spec/spec_helper.rb
+has_rdoc: