Heinous Quadtree crimes.

[ipdf/code.git] / src / quadtree.cpp

diff --git a/src/quadtree.cpp b/src/quadtree.cpp
index b0c0eb5..8474a7f 100644 (file)
--- a/src/quadtree.cpp
+++ b/src/quadtree.cpp
@@ -65,10 +65,11 @@ bool ContainedInQuadChild(const Rect& src, QuadTreeNodeChildren child_type)
 
 
 
-QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir)
+QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir) const
 {
        if (!xdir && !ydir) return start;
 
+       QuadTreeIndex newNode;
        // Try moving to the right if that's easy.
        if (xdir > 0)
        {
@@ -76,23 +77,27 @@ QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir)
                {
                case QTC_TOP_LEFT:
                case QTC_BOTTOM_LEFT:
-                       QuadTreeIndex newNode;
+               {
                        if (nodes[start].child_type == QTC_TOP_LEFT)
-                               newNode = node[nodes[start].parent].top_right;
+                               newNode = nodes[nodes[start].parent].top_right;
                        else
-                               newNode = node[nodes[start].parent].bottom_right;
+                               newNode = nodes[nodes[start].parent].bottom_right;
                                
                        return GetNeighbour(newNode, xdir - 1, ydir);
+               }
                case QTC_TOP_RIGHT:
                case QTC_BOTTOM_RIGHT:
+               {
                        QuadTreeIndex right_parent = GetNeighbour(nodes[start].parent, 1, 0);
                        if (right_parent == -1) return -1;
-                       QuadTreeIndex newNode;
                        if (nodes[start].child_type == QTC_TOP_RIGHT)
-                               newNode = node[right_parent].top_left;
+                               newNode = nodes[right_parent].top_left;
                        else
-                               newNode = node[right_parent].bottom_left;
+                               newNode = nodes[right_parent].bottom_left;
                        return GetNeighbour(newNode, xdir - 1, ydir);
+               }
+               default:
+                       return -1;
 
                }
        }
@@ -104,24 +109,27 @@ QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir)
                {
                case QTC_TOP_RIGHT:
                case QTC_BOTTOM_RIGHT:
-                       QuadTreeIndex newNode;
+               {
                        if (nodes[start].child_type == QTC_TOP_RIGHT)
-                               newNode = node[nodes[start].parent].top_left;
+                               newNode = nodes[nodes[start].parent].top_left;
                        else
-                               newNode = node[nodes[start].parent].bottom_left;
+                               newNode = nodes[nodes[start].parent].bottom_left;
                                
                        return GetNeighbour(newNode, xdir + 1, ydir);
+               }
                case QTC_TOP_LEFT:
                case QTC_BOTTOM_LEFT:
+               {
                        QuadTreeIndex left_parent = GetNeighbour(nodes[start].parent, -1, 0);
                        if (left_parent == -1) return -1;
-                       QuadTreeIndex newNode;
                        if (nodes[start].child_type == QTC_TOP_LEFT)
-                               newNode = node[left_parent].top_right;
+                               newNode = nodes[left_parent].top_right;
                        else
-                               newNode = node[left_parent].bottom_right;
+                               newNode = nodes[left_parent].bottom_right;
                        return GetNeighbour(newNode, xdir + 1, ydir);
-
+               }
+               default:
+                       return -1;
                }
        }
        
@@ -132,24 +140,27 @@ QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir)
                {
                case QTC_TOP_LEFT:
                case QTC_TOP_RIGHT:
-                       QuadTreeIndex newNode;
+               {
                        if (nodes[start].child_type == QTC_TOP_LEFT)
-                               newNode = node[nodes[start].parent].bottom_left;
+                               newNode = nodes[nodes[start].parent].bottom_left;
                        else
-                               newNode = node[nodes[start].parent].bottom_right;
+                               newNode = nodes[nodes[start].parent].bottom_right;
                                
                        return GetNeighbour(newNode, xdir, ydir - 1);
+               }
                case QTC_BOTTOM_LEFT:
                case QTC_BOTTOM_RIGHT:
+               {
                        QuadTreeIndex bottom_parent = GetNeighbour(nodes[start].parent, 0, 1);
                        if (bottom_parent == -1) return -1;
-                       QuadTreeIndex newNode;
                        if (nodes[start].child_type == QTC_BOTTOM_LEFT)
-                               newNode = node[bottom__parent].top_left;
+                               newNode = nodes[bottom_parent].top_left;
                        else
-                               newNode = node[bottom_parent].top_right;
+                               newNode = nodes[bottom_parent].top_right;
                        return GetNeighbour(newNode, xdir, ydir - 1);
-
+               }
+               default:
+                       return -1;
                }
        }
 
@@ -160,24 +171,27 @@ QuadTreeIndex QuadTree::GetNeighbour(QuadTreeIndex start, int xdir, int ydir)
                {
                case QTC_BOTTOM_LEFT:
                case QTC_BOTTOM_RIGHT:
-                       QuadTreeIndex newNode;
+               {
                        if (nodes[start].child_type == QTC_BOTTOM_LEFT)
-                               newNode = node[nodes[start].parent].top_left;
+                               newNode = nodes[nodes[start].parent].top_left;
                        else
-                               newNode = node[nodes[start].parent].top_right;
+                               newNode = nodes[nodes[start].parent].top_right;
                                
                        return GetNeighbour(newNode, xdir, ydir + 1);
+               }
                case QTC_TOP_LEFT:
-               case QTC_BOTTOM_LEFT:
+               case QTC_TOP_RIGHT:
+               {
                        QuadTreeIndex top_parent = GetNeighbour(nodes[start].parent, 0, -1);
                        if (top_parent == -1) return -1;
-                       QuadTreeIndex newNode;
                        if (nodes[start].child_type == QTC_TOP_LEFT)
-                               newNode = node[top_parent].bottom_left;
+                               newNode = nodes[top_parent].bottom_left;
                        else
-                               newNode = node[top_parent].bottom_right;
+                               newNode = nodes[top_parent].bottom_right;
                        return GetNeighbour(newNode, xdir, ydir + 1);
-
+               }
+               default:
+                       return -1;
                }
        }
        return -1;