chingu-pathfinding 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8858650c171257bdd67fb05a33dd949d39571085
-  data.tar.gz: d4752cef76413e77f5eed22aa64826688c90b222
+  metadata.gz: acbba82b0ce19c59d1968606277fca2f0ce65794
+  data.tar.gz: 3d4aa10838504fa9ce82a7116fcca2afe3a35868
 SHA512:
-  metadata.gz: ec0100d0ac4eb14e8e76121b3c2949310971a6bf9ce825580c0e6d12300c667a29f3c20750436d97212b71342b918db2f22e5689283c2e8da061320cabbb2856
-  data.tar.gz: 16617428a3c769015618d6b89579a525f15dc65db5ad0a73a10b64257489807ed0e6b80a3aa896058ca4539fd96b32856244775a694d2cbe356993c0a337be8b
+  metadata.gz: 4ba0c8c9f2905de61d1c7491fd222a073b0dc161221dc772ca6803e593d497641e46a666a7f05aa7bb97591293e678c67046616f7fd53a408ec5b768e5188898
+  data.tar.gz: 42bd5a22cc0b2ea8cb93b25d78e1fdd66fdc820e6c096a73fc9e86f2216a719cafc5904d65feb81e7cc20992e7233996a138f4b35120a6fec685654e9c5ff2e2

data/ext/chingu_pathfinding/chingu_pathfinding.cpp

@@ -1,9 +1,9 @@
 #include <ruby.h>
 #include <math.h>
 #include <vector>
-#include <map>
+#include <unordered_map>
 #include <queue>
-#include <set>
+#include <unordered_set>
 #include <iostream>
 #include <algorithm>
 #include <functional>
@@ -19,16 +19,30 @@ extern "C" {
   }
 }
 
-int dir(const long int a, const long int b) {
+namespace std {
+  template<typename a, typename b>
+  struct hash< std::pair<a, b> > {
+  private:
+     const hash<a> ah;
+     const hash<b> bh;
+  public:
+     hash() : ah(), bh() {}
+     size_t operator()(const std::pair<a, b> &p) const {
+        return ah(p.first) ^ bh(p.second) << 5 ^ bh(p.second);
+     }
+  };
+}
+
+inline int dir(const int a, const int b) {
   if (a == b) return 0;
   if (a < b)  return 1;
   return -1;
 }
 
 struct point_t {
-  long int x, y;
+  int x, y;
   bool valid;
-  point_t(long int xx, long int yy) {
+  point_t(int xx, int yy) {
     x = xx;
     y = yy;
     valid = true;
@@ -36,7 +50,7 @@ struct point_t {
   point_t() : x(0), y(0), valid(false) { }
   point_t(const point_t& p) : x(p.x), y(p.y), valid(p.valid) { }
 };
-typedef std::pair<long int, long int> location_t;
+typedef std::pair<int, int> location_t;
 
 float dist(const location_t& a, const location_t& b) {
   float dx = a.first-b.first;
@@ -45,19 +59,19 @@ float dist(const location_t& a, const location_t& b) {
 }
 
 class path_t {
-  std::map< location_t, point_t >* map_p;
-  std::multimap< location_t, location_t >* connectivity_p;
+  std::unordered_map< location_t, point_t >* map_p;
+  std::unordered_multimap< location_t, location_t >* connectivity_p;
   float cost_paid;
 
   public:
   std::vector<location_t> path;
-  path_t() : cost_paid(0) { }
+  path_t() : cost_paid(0), map_p(NULL), connectivity_p(NULL) { }
   path_t(const path_t& p) : map_p(p.map_p), connectivity_p(p.connectivity_p), path(p.path), cost_paid(p.cost_paid) { }
-  path_t(std::map< location_t, point_t >* mm,
-      std::multimap< location_t, location_t >* cc) 
+  path_t(std::unordered_map< location_t, point_t >* mm,
+      std::unordered_multimap< location_t, location_t >* cc) 
     : map_p(mm), connectivity_p(cc), cost_paid(0), path() { }
   float get_cost_paid() const { return cost_paid; }
-  void add_loc(location_t l, const location_t& goal) {
+  void add_loc(const location_t& l, const location_t& goal) {
     if (!path.empty()) {
       location_t last = *path.crbegin();
       cost_paid += dist(last, l);
@@ -87,23 +101,23 @@ class by_estimated_cost {
 
 
 class pathfinder_t {
-  std::map< location_t, point_t > map; // Spartial hashing
-  std::multimap< location_t, location_t > connectivity; // sparse connectivity
-  long int height, width, block_size;
+  std::unordered_map< location_t, point_t > map; // Spartial hashing
+  std::unordered_multimap< location_t, location_t > connectivity; // sparse connectivity
+  int height, width, block_size;
   ID blocked_method;
   VALUE self;
 
-  bool is_blocked(const long int x, const long int y) {
+  bool is_blocked(const int x, const int y) {
     VALUE blocked = rb_funcall(self, blocked_method, 2, INT2NUM(x), INT2NUM(y));
     return blocked != Qfalse && blocked != Qnil;
   }
 
-  bool line_blocked(const long int x1, const long int y1, const long int x2, const long int y2) {
+  bool line_blocked(const int x1, const int y1, const int x2, const int y2) {
     if (block_size == 1) return false;
-    long int dx = dir(x1, x2);
-    long int dy = dir(y1, y2);
-    long int runner_x = x1;
-    long int runner_y = y1;
+    int dx = dir(x1, x2);
+    int dy = dir(y1, y2);
+    int runner_x = x1;
+    int runner_y = y1;
     while (runner_x * dx <= x2 * dx &&
         runner_y * dy <= y2 * dy) {
       if (is_blocked(runner_x, runner_y)) {
@@ -116,11 +130,11 @@ class pathfinder_t {
   }
 
   typedef std::priority_queue<path_t, std::vector<path_t>, by_estimated_cost> queue_t;
-  path_t find_path_internal(queue_t queue, location_t goal) {
-    std::set<location_t> visited;
+  path_t find_path_internal(queue_t& queue, location_t& goal) {
+    std::unordered_set<location_t> visited;
     while (!queue.empty()) {
       path_t current = queue.top();
-      location_t end = current.end();
+      const location_t& end = current.end();
       queue.pop();
       if (visited.find(end) != visited.end()) continue;
       visited.insert(end);
@@ -136,7 +150,7 @@ class pathfinder_t {
         if (visited.find(to) != visited.end()){
           continue;
         }
-        path_t new_path = current;
+        path_t new_path(current);
         new_path.add_loc(to, goal);
         queue.push(new_path);
       }
@@ -145,14 +159,14 @@ class pathfinder_t {
   }
 
   public:
-  path_t find_path(long int x1, long int y1, long int x2, long int y2) {
+  path_t find_path(int x1, int y1, int x2, int y2) {
     location_t start(x1,y1);
     location_t goal(x2,y2);
     by_estimated_cost estimator(goal);
     queue_t queue(estimator);
     path_t init_path(&map, &connectivity);
-    long int next_node_x = (x1 / block_size)*block_size + block_size/2;
-    long int next_node_y = (y1 / block_size)*block_size + block_size/2;
+    int next_node_x = (x1 / block_size)*block_size + block_size/2;
+    int next_node_y = (y1 / block_size)*block_size + block_size/2;
     init_path.add_loc(start, goal);
     location_t start_block(next_node_x, next_node_y);
     if (start != start_block) {
@@ -162,7 +176,7 @@ class pathfinder_t {
     return find_path_internal(queue, goal);
   }
 
-  path_t find_path_update(long int x1, long int y1, long int x2, long int y2, std::vector<location_t> current) {
+  path_t find_path_update(int x1, int y1, int x2, int y2, std::vector<location_t> current) {
     location_t start(x1,y1);
     location_t goal(x2,y2);
     path_t init_path;
@@ -190,15 +204,17 @@ class pathfinder_t {
     return find_path_internal(queue, goal);
   }
 
-  void Init(VALUE self, long int width, long int height, long int block_size) {
+  void Init(VALUE self, int width, int height, int block_size) {
     this->width = width;
     this->height = height;
     this->block_size = block_size;
     this->self = self;
+    this->map.reserve(width/block_size * height/block_size);
+    this->connectivity.reserve(width/block_size * height/block_size*4);
     blocked_method = rb_intern("blocked?");
     // Build internal map:
-    for (long int x = block_size/2; x < width; x += block_size) {
-      for (long int y = block_size/2; y < height; y += block_size) {
+    for (int x = block_size/2; x < width; x += block_size) {
+      for (int y = block_size/2; y < height; y += block_size) {
         //   add point if it is not blocked
         if (is_blocked(x, y)) continue;
         auto cur_loc = location_t(x,y);
@@ -236,20 +252,19 @@ class pathfinder_t {
         }
       }
     }
-    // print_map();
   } // END Init
 
   std::string print_map() {
     // DEBUGGING
 
-    auto mapp = std::map<location_t, char>();
-    for (long int x = 0; x < width; x++) {
-      for (long int y = 0; y < height; y++) {
+    auto mapp = std::unordered_map<location_t, char>();
+    for (int x = 0; x < width; x++) {
+      for (int y = 0; y < height; y++) {
         mapp[location_t(x, y)] = ' ';
       }
     }
-    for (long int x = block_size/2; x < width; x += block_size) {
-      for (long int y = block_size/2; y < height; y += block_size) {
+    for (int x = block_size/2; x < width; x += block_size) {
+      for (int y = block_size/2; y < height; y += block_size) {
         if (!map[location_t(x, y)].valid) {
           mapp[location_t(x, y)] = '~';
           continue;
@@ -269,9 +284,9 @@ class pathfinder_t {
     }
     std::stringstream out;
     out << "map:";
-    for (long int y = 0; y < height; y++) {
+    for (int y = 0; y < height; y++) {
       out << std::endl;
-      for (long int x = 0; x < width; x++) {
+      for (int x = 0; x < width; x++) {
         out << mapp[location_t(x, y)];
       }
     }
@@ -293,8 +308,6 @@ static VALUE alloc_pathfinder(VALUE klass) {
 
 static VALUE init(VALUE self, VALUE width_a, VALUE height_a, VALUE block_size_a) {
   pathfinder_t* pf;
-  long int width, height, block_size;
-  long int x, y;
   Data_Get_Struct(self, pathfinder_t, pf);
   pf->Init(self, NUM2INT(width_a), NUM2INT(height_a), NUM2INT(block_size_a));
   return self;
@@ -320,8 +333,8 @@ static VALUE find_path_update(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2
   std::vector<location_t> p;
   for (int i = 0; i < len; i++) {
     VALUE pt = rb_ary_shift(prev);
-    long int x = NUM2INT(rb_ary_shift(pt));
-    long int y = NUM2INT(rb_ary_shift(pt));
+    int x = NUM2INT(rb_ary_shift(pt));
+    int y = NUM2INT(rb_ary_shift(pt));
     p.push_back(location_t(x, y));
   }
   path_t path = pf->find_path_update(NUM2INT(x1), NUM2INT(y1), NUM2INT(x2), NUM2INT(y2), p);

data/ext/chingu_pathfinding/extconf.rb

@@ -14,4 +14,5 @@ end
 have_header("ruby.h")
 have_library("stdc++")
 try_compiler_option('-std=c++11')
+try_compiler_option('-O3')
 create_makefile('chingu_pathfinding/chingu_pathfinding')

data/lib/chingu_pathfinding.rb

@@ -1,5 +1,5 @@
 class Pathfinding
-  VERSION = '1.1.2'
+  VERSION = '1.1.3'
   def find_path(x1, y1, x2, y2)
     throw "Require points to be numeric, got #{[x1, y1, x2, y2]}." unless [x1,y1,x2,y2].all? {|x| x.kind_of?(Numeric)}
     _find_path(x1, y1, x2, y2)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chingu-pathfinding
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - zombiecalypse