refactor + cleanup

sys/apis/jumper/core/bheap.lua

@@ -1,14 +1,14 @@
 --- A light implementation of Binary heaps data structure.
 -- While running a search, some search algorithms (Astar, Dijkstra, Jump Point Search) have to maintains
--- a list of nodes called __open list__. Retrieve from this list the lowest cost node can be quite slow, 
--- as it normally requires to skim through the full set of nodes stored in this list. This becomes a real 
--- problem especially when dozens of nodes are being processed (on large maps). 
+-- a list of nodes called __open list__. Retrieve from this list the lowest cost node can be quite slow,
+-- as it normally requires to skim through the full set of nodes stored in this list. This becomes a real
+-- problem especially when dozens of nodes are being processed (on large maps).
 --
 -- The current module implements a <a href="http://www.policyalmanac.org/games/binaryHeaps.htm">binary heap</a>
--- data structure, from which the search algorithm will instantiate an open list, and cache the nodes being 
--- examined during a search. As such, retrieving the lower-cost node is faster and globally makes the search end 
+-- data structure, from which the search algorithm will instantiate an open list, and cache the nodes being
+-- examined during a search. As such, retrieving the lower-cost node is faster and globally makes the search end
 -- up quickly.
--- 
+--
 -- This module is internally used by the library on purpose.
 -- It should normally not be used explicitely, yet it remains fully accessible.
 --
@@ -23,7 +23,7 @@ if (...) then
 
 	-- Dependency
 	local Utils = require((...):gsub('%.bheap$','.utils'))
-	
+
 	-- Local reference
 	local floor = math.floor
 
@@ -40,7 +40,7 @@ if (...) then
 		else pIndex = (index-1)/2
 		end
 		if not heap._sort(heap._heap[pIndex], heap._heap[index]) then
-			heap._heap[pIndex], heap._heap[index] = 
+			heap._heap[pIndex], heap._heap[index] =
 				heap._heap[index], heap._heap[pIndex]
 			percolate_up(heap, pIndex)
 		end
@@ -89,7 +89,7 @@ if (...) then
 	-- @class function
 	-- @treturn bool __true__ of no item is queued in the heap, __false__ otherwise
 	-- @usage
-	-- if myHeap:empty() then 
+	-- if myHeap:empty() then
 	--   print('Heap is empty!')
 	-- end
 	function heap:empty()
@@ -129,7 +129,7 @@ if (...) then
 	-- @class function
 	-- @treturn value a value previously pushed into the heap
 	-- @usage
-	-- while not myHeap:empty() do 
+	-- while not myHeap:empty() do
 	--   local lowestValue = myHeap:pop()
 	--   ...
 	-- end
@@ -148,18 +148,18 @@ if (...) then
 	end
 
 	--- Restores the `heap` property.
-	-- Reorders the `heap` with respect to the comparison function being used. 
-	-- When given argument __item__ (a value existing in the `heap`), will sort from that very item in the `heap`. 
-	-- Otherwise, the whole `heap` will be cheacked. 
+	-- Reorders the `heap` with respect to the comparison function being used.
+	-- When given argument __item__ (a value existing in the `heap`), will sort from that very item in the `heap`.
+	-- Otherwise, the whole `heap` will be cheacked.
 	-- @class function
 	-- @tparam[opt] value item the modified value
 	-- @treturn heap self (the calling `heap` itself, can be chained)
-	-- @usage myHeap:heapify() 
+	-- @usage myHeap:heapify()
 	function heap:heapify(item)
 		if self._size == 0 then return end
 		if item then
 			local i = Utils.indexOf(self._heap,item)
-			if i then 
+			if i then
 				percolate_down(self, i)
 				percolate_up(self, i)
 			end

sys/apis/jumper/core/node.lua

@@ -7,59 +7,26 @@
 -- made with regards of their `f` cost. From a given node being examined, the `pathfinder` will expand the search
 -- to the next neighbouring node having the lowest `f` cost. See `core.bheap` for more details.
 --
-
 if (...) then
 
-	--- The `Node` class.<br/>
-	-- This class is callable.
-	-- Therefore,_ <code>Node(...)</code> _acts as a shortcut to_ <code>Node:new(...)</code>.
-	-- @type Node
   local Node = {}
   Node.__index = Node
 
-  --- Inits a new `node`
-  -- @class function
-  -- @tparam int x the x-coordinate of the node on the collision map
-  -- @tparam int y the y-coordinate of the node on the collision map
-  -- @treturn node a new `node`
-	-- @usage local node = Node(3,4)
   function Node:new(x,y,z)
-    return setmetatable({_x = x, _y = y, _z = z }, Node)
+    return setmetatable({x = x, y = y, z = z }, Node)
   end
 
   -- Enables the use of operator '<' to compare nodes.
   -- Will be used to sort a collection of nodes in a binary heap on the basis of their F-cost
   function Node.__lt(A,B) return (A._f < B._f) end
 
-  --- Returns x-coordinate of a `node`
-  -- @class function
-  -- @treturn number the x-coordinate of the `node`
-	-- @usage local x = node:getX()
-	function Node:getX() return self._x end
-
-  --- Returns y-coordinate of a `node`
-  -- @class function
-  -- @treturn number the y-coordinate of the `node`
-	-- @usage local y = node:getY()
-	function Node:getY() return self._y end
-
-	function Node:getZ() return self._z end
-
-  --- Returns x and y coordinates of a `node`
-  -- @class function
-  -- @treturn number the x-coordinate of the `node`
-  -- @treturn number the y-coordinate of the `node`
-	-- @usage local x, y = node:getPos()
-	function Node:getPos() return self._x, self._y, self._z end
+	function Node:getX() return self.x end
+	function Node:getY() return self.y end
+	function Node:getZ() return self.z end
 
 	--- Clears temporary cached attributes of a `node`.
 	-- Deletes the attributes cached within a given node after a pathfinding call.
 	-- This function is internally used by the search algorithms, so you should not use it explicitely.
-	-- @class function
-	-- @treturn node self (the calling `node` itself, can be chained)
-	-- @usage
-	-- local thisNode = Node(1,2)
-	-- thisNode:reset()
 	function Node:reset()
 		self._g, self._h, self._f = nil, nil, nil
 		self._opened, self._closed, self._parent = nil, nil, nil

sys/apis/jumper/core/path.lua

@@ -7,27 +7,18 @@
 --
 
 if (...) then
-	--- The `Path` class.<br/>
-	-- This class is callable.
-	-- Therefore, <em><code>Path(...)</code></em> acts as a shortcut to <em><code>Path:new(...)</code></em>.
-	-- @type Path
+
+  local t_remove = table.remove
+
   local Path = {}
   Path.__index = Path
 
-  --- Inits a new `path`.
-  -- @class function
-  -- @treturn path a `path`
-	-- @usage local p = Path()
   function Path:new()
     return setmetatable({_nodes = {}}, Path)
   end
 
   --- Iterates on each single `node` along a `path`. At each step of iteration,
   -- returns the `node` plus a count value. Aliased as @{Path:nodes}
-  -- @class function
-  -- @treturn node a `node`
-  -- @treturn int the count for the number of nodes
-	-- @see Path:nodes
 	-- @usage
 	-- for node, count in p:iter() do
 	--   ...
@@ -42,6 +33,32 @@ if (...) then
     end
   end
 
+  --- `Path` compression modifier. Given a `path`, eliminates useless nodes to return a lighter `path`
+  -- consisting of straight moves. Does the opposite of @{Path:fill}
+  -- @class function
+  -- @treturn path self (the calling `path` itself, can be chained)
+  -- @see Path:fill
+  -- @usage p:filter()
+  function Path:filter()
+    local i = 2
+    local xi,yi,zi,dx,dy,dz, olddx, olddy, olddz
+    xi,yi,zi = self._nodes[i].x, self._nodes[i].y, self._nodes[i].z
+    dx, dy,dz = xi - self._nodes[i-1].x, yi-self._nodes[i-1].y, zi-self._nodes[i-1].z
+    while true do
+      olddx, olddy, olddz = dx, dy, dz
+      if self._nodes[i+1] then
+        i = i+1
+        xi, yi, zi = self._nodes[i].x, self._nodes[i].y, self._nodes[i].z
+        dx, dy, dz = xi - self._nodes[i-1].x, yi - self._nodes[i-1].y, zi - self._nodes[i-1].z
+        if olddx == dx and olddy == dy and olddz == dz then
+          t_remove(self._nodes, i-1)
+          i = i - 1
+        end
+      else break end
+    end
+    return self
+  end
+
   return setmetatable(Path,
     {__call = function(_,...)
       return Path:new(...)