gingham 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5e2ea88b53bf0062410a2cc325c7107ef76faaa
-  data.tar.gz: 219437f00a6e6f602bd796fc1953f5c89d241df8
+  metadata.gz: 5f4ff2ca6e1ddb2e09b7c38b0fb695fbca6b1b9b
+  data.tar.gz: c0e7e93a7e5c13921d5ec4f1a34843e41e6993b4
 SHA512:
-  metadata.gz: 3ee418f8f6e68fcd50f9dd28de51c2e331ac38e2be863766d28d2874b6dede31a342aabfdb0fa8aa947b9db9e39e41fc6fc447f6b3f2f318576f668720c4912b
-  data.tar.gz: bf1711370c367ff688d4e14b4ff11caf9a0ea36b9dcd3baf34d0e0c14ac39d2bf6333a3997e97301ff5c1459f801193e0c4b0ce05fcd680a606e3a4a85c345c4
+  metadata.gz: a5fe647461cec8da29c6f46c3b088e8de6687c7de996948de66b2e5591d3103b28ce64d265309128df8c3bc07d373b68c3959a137fd3890a76bbdef88161d2db
+  data.tar.gz: e3ba843d637ae944ca2cfd18fcbea6897d3079f15b643392977ae230b1c2bf67d163b67e03a89a1998ddb1739e5a12136e279b6ec1c945eb15f1eb3827fa11c9

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
   - 2.2.4
+  - 2.3.0
 before_install: gem install bundler -v 1.11.2

data/README.md

@@ -1,6 +1,7 @@
 # Gingham
 
 [![Build Status](https://travis-ci.org/cignoir/gingham.svg?branch=master)](https://travis-ci.org/cignoir/gingham)
+[![Coverage Status](https://coveralls.io/repos/github/cignoir/gingham/badge.svg?branch=master)](https://coveralls.io/github/cignoir/gingham?branch=master)
 
 ## Installation
 

data/gingham.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", '~> 1.11', '>= 1.11.2'
   spec.add_development_dependency "rake", '~> 11.1', '>= 11.1.2'
   spec.add_development_dependency "rspec", '~> 3.4', '>= 3.4.0'
+  spec.add_development_dependency(%q<coveralls>, [">= 0"])
 end

data/lib/gingham/actor.rb

@@ -4,12 +4,15 @@ module Gingham
     attr_accessor :move_steps
     attr_accessor :team_id
     attr_accessor :move_status
+    attr_accessor :move_power, :jump_power
 
-    def initialize(waypoint, weight = 100, team_id = 0)
+    def initialize(waypoint, weight = 100, team_id = 0, move_power = 999, jump_power = 999)
       @waypoint = waypoint
       @weight = weight
       @team_id = team_id
       @move_status = Gingham::MoveStatus::DEFAULT
+      @move_power = move_power
+      @jump_power = jump_power
     end
 
     def move_end?

data/lib/gingham/cell.rb

@@ -12,7 +12,6 @@ module Gingham
       other.is_a?(Gingham::Cell) && @x == other.x && @y == other.y && @z == other.z
     end
 
-    #FIXME
     def occupied?
       @is_occupied
     end
@@ -36,5 +35,10 @@ module Gingham
     def inspect
       "(#{x},#{y},#{z})"
     end
+
+    def set_ground
+      @is_ground = true
+      self
+    end
   end
 end

data/lib/gingham/path_finder.rb

@@ -1,7 +1,7 @@
 module Gingham
   class PathFinder
     class << self
-      def find_move_path(space, from, to, cost_limit = 999)
+      def find_move_path(space, from, to, move_power = 999, jump_power = 999)
         raise ArgumentError unless space && space.is_a?(Gingham::Space)
         raise ArgumentError unless from && from.is_a?(Gingham::Waypoint) && to && to.is_a?(Gingham::Waypoint)
 
@@ -15,9 +15,9 @@ module Gingham
           close_list << current_wp
           open_list = open_list.drop 1
 
-          adjacent_waypoints = Gingham::PathFinder.find_adjacent_waypoints(space, current_wp)
+          adjacent_waypoints = Gingham::PathFinder.find_adjacent_waypoints(space, current_wp, jump_power)
           adjacent_waypoints.each do |wp|
-            if wp.sum_cost < cost_limit
+            if wp.sum_cost < move_power
               open_list << wp unless close_list.include? wp
             end
           end
@@ -25,7 +25,7 @@ module Gingham
         end
 
         shortest_chains = [from]
-        end_points = close_list.select{ |closed| closed.cell == to.cell }
+        end_points = close_list.select { |closed| closed.cell == to.cell }
 
         unless end_points.size.zero?
           shortest_cost = 999
@@ -39,56 +39,41 @@ module Gingham
         shortest_chains
       end
 
-      def find_skill_path(space, from, to, max_height = 10)
+      def find_skill_path(space, from, to, max_height = 999)
         path = [from]
-        last_wp = path.last
         should_move_y = from.direction == Gingham::Direction::D8 || from.direction == Gingham::Direction::D2
 
         loop_limit = 0
-        while last_wp.cell.x != to.cell.x || last_wp.cell.y != to.cell.y
+        while path.last.cell.x != to.cell.x || path.last.cell.y != to.cell.y
           loop_limit += 1
           break if loop_limit > 30
 
-          if should_move_y && last_wp.cell.y != to.cell.y
-            if last_wp.cell.y < to.cell.y
-              if last_wp.cell.y + 1 != space.depth
-                height = space.height_at(last_wp.cell.x, last_wp.cell.y + 1)
-                cell = space.cells[last_wp.cell.x][last_wp.cell.y + 1][height]
+          if should_move_y && path.last.cell.y != to.cell.y
+            if path.last.cell.y < to.cell.y
+              if path.last.cell.y + 1 != space.depth
+                height = space.height_at(path.last.cell.x, path.last.cell.y + 1)
+                cell = space.cells[path.last.cell.x][path.last.cell.y + 1][height]
                 break unless cell.passable?
 
-                if last_wp.direction == 8
-                  break if cell.z > max_height
-                  wp = Gingham::Waypoint.new(cell, 8, last_wp)
-                  path << wp
-                  last_wp = wp
-                else
-                  tmp = Gingham::Waypoint.new(last_wp.cell, 8, last_wp)
-                  path << tmp
-                  break if cell.z > max_height
-                  tmp = Gingham::Waypoint.new(cell, 8, tmp)
-                  path << tmp
-                  last_wp = tmp
+                if path.last.direction != 8
+                  path << Gingham::Waypoint.new(path.last.cell, 8, path.last)
                 end
+
+                break if cell.z > max_height
+                path << Gingham::Waypoint.new(cell, 8, path.last)
               end
-            elsif last_wp.cell.y > to.cell.y
-              if last_wp.cell.y - 1 >= 0
-                height = space.height_at(last_wp.cell.x, last_wp.cell.y - 1)
-                cell = space.cells[last_wp.cell.x][last_wp.cell.y - 1][height]
+            elsif path.last.cell.y > to.cell.y
+              if path.last.cell.y - 1 >= 0
+                height = space.height_at(path.last.cell.x, path.last.cell.y - 1)
+                cell = space.cells[path.last.cell.x][path.last.cell.y - 1][height]
                 break unless cell.passable?
 
-                if last_wp.direction == 2
-                  break if cell.z > max_height
-                  wp = Gingham::Waypoint.new(cell, 2, last_wp)
-                  path << wp
-                  last_wp = wp
-                else
-                  tmp = Gingham::Waypoint.new(last_wp.cell, 2, last_wp)
-                  path << tmp
-                  break if cell.z > max_height
-                  tmp = Gingham::Waypoint.new(cell, 2, tmp)
-                  path << tmp
-                  last_wp = tmp
+                if path.last.direction != 2
+                  path << Gingham::Waypoint.new(path.last.cell, 2, path.last)
                 end
+
+                break if cell.z > max_height
+                path << Gingham::Waypoint.new(cell, 2, path.last)
               end
             end
             should_move_y = false
@@ -97,65 +82,49 @@ module Gingham
             should_move_y = false
           end
 
-          if !should_move_y && last_wp.cell.x != to.cell.x
-            if last_wp.cell.x < to.cell.x
-              if last_wp.cell.x + 1 != space.width
-                height = space.height_at(last_wp.cell.x + 1, last_wp.cell.y)
-                cell = space.cells[last_wp.cell.x + 1][last_wp.cell.y][height]
+          if !should_move_y && path.last.cell.x != to.cell.x
+            if path.last.cell.x < to.cell.x
+              if path.last.cell.x + 1 != space.width
+                height = space.height_at(path.last.cell.x + 1, path.last.cell.y)
+                cell = space.cells[path.last.cell.x + 1][path.last.cell.y][height]
                 break unless cell.passable?
 
-                if last_wp.direction == 6
-                  break if cell.z > max_height
-                  wp = Gingham::Waypoint.new(cell, 6, last_wp)
-                  path << wp
-                  last_wp = wp
-                else
-                  tmp = Gingham::Waypoint.new(last_wp.cell, 6, last_wp)
-                  path << tmp
-                  break if cell.z > max_height
-                  tmp = Gingham::Waypoint.new(cell, 6, tmp)
-                  path << tmp
-                  last_wp = tmp
+                if path.last.direction != 6
+                  path << Gingham::Waypoint.new(path.last.cell, 6, path.last)
                 end
+
+                break if cell.z > max_height
+                path << Gingham::Waypoint.new(cell, 6, path.last)
               end
-            elsif last_wp.cell.x > to.cell.x
-              if last_wp.cell.x - 1 >= 0
-                height = space.height_at(last_wp.cell.x - 1, last_wp.cell.y)
-                cell = space.cells[last_wp.cell.x - 1][last_wp.cell.y][height]
+            elsif path.last.cell.x > to.cell.x
+              if path.last.cell.x - 1 >= 0
+                height = space.height_at(path.last.cell.x - 1, path.last.cell.y)
+                cell = space.cells[path.last.cell.x - 1][path.last.cell.y][height]
                 break unless cell.passable?
 
-                if last_wp.direction == 4
-                  break if cell.z > max_height
-                  wp = Gingham::Waypoint.new(cell, 4, last_wp)
-                  path << wp
-                  last_wp = wp
-                else
-                  tmp = Gingham::Waypoint.new(last_wp.cell, 4, last_wp)
-                  path << tmp
-                  break if cell.z > max_height
-                  tmp = Gingham::Waypoint.new(cell, 4, tmp)
-                  path << tmp
-                  last_wp = tmp
+                if path.last.direction != 4
+                  path << Gingham::Waypoint.new(path.last.cell, 4, path.last)
                 end
+
+                break if cell.z > max_height
+                path << Gingham::Waypoint.new(cell, 4, path.last)
               end
             end
-            should_move_y = true
-            next
-          else
-            should_move_y = true
           end
+
+          should_move_y = true
         end
 
         path.compact
       end
     end
 
-    def self.find_adjacent_waypoints(space, wp)
+    def self.find_adjacent_waypoints(space, wp, jump_power = 999)
       raise unless space && space.is_a?(Gingham::Space)
       raise unless wp && wp.is_a?(Gingham::Waypoint)
 
       adjacent_list = []
-      adjacent_cells = Gingham::PathFinder.find_adjacent_cells(space, wp.cell)
+      adjacent_cells = Gingham::PathFinder.find_adjacent_cells(space, wp.cell, jump_power)
       adjacent_cells.each do |cell|
         move_direction = Gingham::Waypoint.detect_direction(wp, cell)
         parent = wp
@@ -169,7 +138,7 @@ module Gingham
       adjacent_list
     end
 
-    def self.find_adjacent_cells(space, cell)
+    def self.find_adjacent_cells(space, cell, jump_power = 999)
       raise unless space && space.is_a?(Gingham::Space)
       raise unless cell && cell.is_a?(Gingham::Cell)
 
@@ -178,23 +147,39 @@ module Gingham
       x, y, z = cell.x, cell.y, cell.z
 
       if x + 1 < w
-        target_cell = space.cells[x + 1][y][z]
-        adjacent_list << target_cell unless target_cell && target_cell.occupied?
+        target_cell = space.ground_at(x + 1, y)
+        if target_cell
+          if !target_cell.occupied? || (z - target_cell.z).abs <= jump_power
+            adjacent_list << target_cell
+          end
+        end
       end
 
       if x - 1 >= 0
-        target_cell = space.cells[x - 1][y][z]
-        adjacent_list << target_cell unless target_cell && target_cell.occupied?
+        target_cell = space.ground_at(x - 1, y)
+        if target_cell
+          if !target_cell.occupied? || (z - target_cell.z).abs <= jump_power
+            adjacent_list << target_cell
+          end
+        end
       end
 
       if y + 1 < d
-        target_cell = space.cells[x][y + 1][z]
-        adjacent_list << target_cell unless target_cell && target_cell.occupied?
+        target_cell = space.ground_at(x, y + 1)
+        if target_cell
+          if !target_cell.occupied? || (z - target_cell.z).abs <= jump_power
+            adjacent_list << target_cell
+          end
+        end
       end
 
       if y - 1 >= 0
-        target_cell = space.cells[x][y - 1][z]
-        adjacent_list << target_cell unless target_cell && target_cell.occupied?
+        target_cell = space.ground_at(x, y - 1)
+        if target_cell
+          if !target_cell.occupied? || (z - target_cell.z).abs <= jump_power
+            adjacent_list << target_cell
+          end
+        end
       end
 
       adjacent_list

data/lib/gingham/space.rb

@@ -1,6 +1,6 @@
 module Gingham
   class Space
-    attr_accessor :width, :height, :depth, :cells
+    attr_accessor :width, :depth, :height, :cells
 
     def initialize(width = 0, depth = 0, height = 0)
       @width = width

data/lib/gingham/version.rb

@@ -1,3 +1,3 @@
 module Gingham
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/gingham/waypoint.rb

@@ -97,9 +97,6 @@ module Gingham
       @parent ? "#{@parent.cell}/#{@parent.direction}->" + base : base
     end
 
-    def inspect
-      base = "#{@cell}/#{@direction}" + ":#{@cost}/#{@sum_cost}"
-      @parent ? "#{@parent.cell}/#{@parent.direction}->" + base : base
-    end
+    alias_method :inspect, :to_s
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gingham
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - cignoir
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2016-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -90,6 +90,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: R.I.P. StruGarden
 email:
 - cignoir@gmail.com
@@ -141,8 +155,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Implementation of original pathfinding algorythm based on 3d grids.
 test_files: []
+has_rdoc: