Ticket #2025: pathfind.patch

source/maths/Sqrt.h

@@ -22 +22 @@
  * 64-bit integer square root.
  * Returns r such that r^2 <= n < (r+1)^2, for the complete u64 range.
  */
-u32 isqrt64(u64 n);
 
+
+// TODO: This should be equivalent to (u32)sqrt((double)n), and in practice
+// that seems to be true for all input, so do we actually need this integer-only
+// implementation? i.e. are there any platforms / compiler settings where
+// sqrt(double) won't give the correct answer? and is sqrt(double) faster?
+// TODO: read, decide and benchmark
+// http://omeg.pl/blog/2012/03/performance-of-various-square-root-computing-algorithms/
+// at least incredibly faster on win64 32bit build. (talking about 15% of cpu profile against 0.1% ...)
+
+//#define NATIVE_SQRT 
+#ifndef NATIVE_SQRT
+static inline u32 isqrt64(const u64 n)
+{
+    u64 one = (u64)1 << 62; // highest power of four <= than the argument
+    while (one > n)
+        one >>= 2;
+
+    u64 op = n;
+    u64 res = 0;
+    while (one != 0)
+    {
+        if (op >= res + one)
+        {
+            op -= (res + one);
+            res += (one << 1);
+        }
+        res >>= 1;
+        one >>= 2;
+    }
+    return (u32)res;
+}
+#else
+    #define isqrt64(n) ((u32)sqrt((double)(n)))
+#endif
+
 #endif // INCLUDED_MATH_SQRT

source/maths/Sqrt.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "Sqrt.h"
-
-// Based on http://freaknet.org/martin/tape/gos/misc/personal/msc/sqrt/sqrt.html
-u32 isqrt64(u64 n)
-{
-    u64 op = n;
-    u64 res = 0;
-    u64 one = (u64)1 << 62; // highest power of four <= than the argument
-
-    while (one > op)
-        one >>= 2;
-
-    while (one != 0)
-    {
-        if (op >= res + one)
-        {
-            op -= (res + one);
-            res += (one << 1);
-        }
-        res >>= 1;
-        one >>= 2;
-    }
-    return (u32)res;
-}
-
-// TODO: This should be equivalent to (u32)sqrt((double)n), and in practice
-// that seems to be true for all input, so do we actually need this integer-only
-// implementation? i.e. are there any platforms / compiler settings where
-// sqrt(double) won't give the correct answer? and is sqrt(double) faster?

source/maths/FixedVector2D.h

@@ -95 +95 @@
     fixed Length() const
     {
         // Do intermediate calculations with 64-bit ints to avoid overflows
-        i64 x = (i64)X.GetInternalValue();
-        i64 y = (i64)Y.GetInternalValue();
-        u64 xx = (u64)(x * x);
-        u64 yy = (u64)(y * y);
-        u64 d2 = xx + yy;
+        const i64 x = (i64)X.GetInternalValue();
+        const i64 y = (i64)Y.GetInternalValue();
+        const u64 xx = (u64)(x * x);
+        const u64 yy = (u64)(y * y);
+        const u64 d2 = xx + yy;
         CheckUnsignedAdditionOverflow(d2, xx, L"Overflow in CFixedVector2D::Length() part 1")
 
-        u32 d = isqrt64(d2);
+        const u32 d = isqrt64(d2);
 
         CheckU32CastOverflow(d, i32, L"Overflow in CFixedVector2D::Length() part 2")
         fixed r;
         r.SetInternalValue((i32)d);
         return r;
     }
+    /**
+     * Returns the squared length of distance bewteen this vector and another
+     * Will not overflow if the result can be represented as type 'fixed'.
+     * faster than comparing two length (saving a squareroot operation)
+     */
+    fixed computeDistanceLengthSquared(const CFixedVector2D& src) const 
+    {       
+        const i64 x = (i64)X.GetInternalValue() - (i64)src.X.GetInternalValue();
+        const i64 y = (i64)Y.GetInternalValue() - (i64)src.Y.GetInternalValue();        
+        const u64 d2 = (u64)(x * x) + (u64)(y * y);
+        fixed r;
+        r.SetInternalValue((i32)(d2 & 0x0000ffff));
+        return r;
+    }
+    
+    /**
+     * Returns the squared length of distance bewteen this vector and another
+     * Will not overflow if the result can be represented as type 'fixed'.
+     */
+    fixed computeDistanceLength(const CFixedVector2D& src) const
+    {
+        const i64 x = (i64)X.GetInternalValue() - (i64)src.X.GetInternalValue();
+        const i64 y = (i64)Y.GetInternalValue() - (i64)src.Y.GetInternalValue();        
+        const u64 xx = (u64)(x * x);
+        const u64 yy = (u64)(y * y);
+        const u64 d2 = xx + yy;
+        CheckUnsignedAdditionOverflow(d2, xx, L"Overflow in CFixedVector2D::Length() part 1")
 
+        const u32 d = isqrt64(d2);
+
+        CheckU32CastOverflow(d, i32, L"Overflow in CFixedVector2D::Length() part 2")
+        fixed r;
+        r.SetInternalValue((i32)d);
+        return r;
+    }
     /**
      * Returns -1, 0, +1 depending on whether length is less/equal/greater
      * than the argument.
@@ -188 +222 @@
             Y = Y.MulDiv(n, l);
         }
     }
+    /**
+     * Compute the dot product of this vector with another.
+     */
+    inline fixed SubFromAndDot(const fixed aX, const fixed aY, const CFixedVector2D& v) const 
+    {
+        i64 x = (i64)(aX - X).GetInternalValue() * (i64)v.X.GetInternalValue();
+        i64 y = (i64)(aY - Y).GetInternalValue() * (i64)v.Y.GetInternalValue();
+        CheckSignedAdditionOverflow(i64, x, y, L"Overflow in CFixedVector2D::Dot() part 1", L"Underflow in CFixedVector2D::Dot() part 1")
+        i64 sum = x + y;
+        sum >>= fixed::fract_bits;
 
+        CheckCastOverflow(sum, i32, L"Overflow in CFixedVector2D::Dot() part 2", L"Underflow in CFixedVector2D::Dot() part 2")
+        fixed ret;
+        ret.SetInternalValue((i32)sum);
+        return ret;
+    }
     /**
      * Compute the dot product of this vector with another.
      */
-    fixed Dot(const CFixedVector2D& v)
+    inline fixed SubAndDot(const CFixedVector2D& b, const CFixedVector2D& v) const 
     {
+        i64 x = (i64)(X - b.X).GetInternalValue() * (i64)v.X.GetInternalValue();
+        i64 y = (i64)(Y - b.Y).GetInternalValue() * (i64)v.Y.GetInternalValue();
+        CheckSignedAdditionOverflow(i64, x, y, L"Overflow in CFixedVector2D::Dot() part 1", L"Underflow in CFixedVector2D::Dot() part 1")
+        i64 sum = x + y;
+        sum >>= fixed::fract_bits;
+
+        CheckCastOverflow(sum, i32, L"Overflow in CFixedVector2D::Dot() part 2", L"Underflow in CFixedVector2D::Dot() part 2")
+        fixed ret;
+        ret.SetInternalValue((i32)sum);
+        return ret;
+    }
+    /**
+     * Compute the dot product of this vector with another.
+     */
+    inline fixed Dot(const CFixedVector2D& v) const 
+    {
         i64 x = (i64)X.GetInternalValue() * (i64)v.X.GetInternalValue();
         i64 y = (i64)Y.GetInternalValue() * (i64)v.Y.GetInternalValue();
         CheckSignedAdditionOverflow(i64, x, y, L"Overflow in CFixedVector2D::Dot() part 1", L"Underflow in CFixedVector2D::Dot() part 1")
@@ -206 +271 @@
         return ret;
     }
 
-    CFixedVector2D Perpendicular()
+    CFixedVector2D Perpendicular() const
     {
         return CFixedVector2D(Y, -X);
     }
@@ -214 +279 @@
     /**
      * Rotate the vector by the given angle (anticlockwise).
      */
-    CFixedVector2D Rotate(fixed angle)
+    CFixedVector2D Rotate(fixed angle) const
     {
         fixed s, c;
         sincos_approx(angle, s, c);

source/maths/Fixed.h

@@ -107 +107 @@
 class CFixed
 {
 private:
-    T value;
 
     explicit CFixed(T v) : value(v) { }
 
 public:
+    T value;
     enum { fract_bits = fract_bits_ };
 
     CFixed() : value(0) { }
@@ -191 +191 @@
     bool IsZero() const { return value == 0; }
 
     /// Equality.
-    bool operator==(CFixed n) const { return (value == n.value); }
+    bool operator==(const CFixed&  n) const { return (value == n.value); }
 
     /// Inequality.
-    bool operator!=(CFixed n) const { return (value != n.value); }
+    bool operator!=(const CFixed&  n) const { return (value != n.value); }
 
     /// Numeric comparison.
-    bool operator<=(CFixed n) const { return (value <= n.value); }
+    bool operator<=(const CFixed&  n) const { return (value <= n.value); }
 
     /// Numeric comparison.
-    bool operator<(CFixed n) const { return (value < n.value); }
+    bool operator<(const CFixed&  n) const { return (value < n.value); }
 
     /// Numeric comparison.
-    bool operator>=(CFixed n) const { return (value >= n.value); }
+    bool operator>=(const CFixed&  n) const { return (value >= n.value); }
 
     /// Numeric comparison.
-    bool operator>(CFixed n) const { return (value > n.value); }
+    bool operator>(const CFixed&  n) const { return (value > n.value); }
 
     // Basic arithmetic:
 
     /// Add a CFixed. Might overflow.
-    CFixed operator+(CFixed n) const
+    CFixed operator+(const CFixed&  n) const
     {
         CheckSignedAdditionOverflow(T, value, n.value, L"Overflow in CFixed::operator+(CFixed n)", L"Underflow in CFixed::operator+(CFixed n)")
         return CFixed(value + n.value);
     }
 
     /// Subtract a CFixed. Might overflow.
-    CFixed operator-(CFixed n) const
+    CFixed operator-(const CFixed&  n) const
     {
         CheckSignedSubtractionOverflow(T, value, n.value, L"Overflow in CFixed::operator-(CFixed n)", L"Underflow in CFixed::operator-(CFixed n)")
         return CFixed(value - n.value);
     }
 
     /// Add a CFixed. Might overflow.
-    CFixed& operator+=(CFixed n) { *this = *this + n; return *this; }
+    CFixed& operator+=(const CFixed&  n) { *this = *this + n; return *this; }
 
     /// Subtract a CFixed. Might overflow.
-    CFixed& operator-=(CFixed n) { *this = *this - n; return *this; }
+    CFixed& operator-=(const CFixed&  n) { *this = *this - n; return *this; }
 
     /// Negate a CFixed.
     CFixed operator-() const
@@ -238 +238 @@
     }
 
     /// Divide by a CFixed. Must not have n.IsZero(). Might overflow.
-    CFixed operator/(CFixed n) const
+    CFixed operator/(const CFixed&  n) const
     {
         i64 t = (i64)value << fract_bits;
         i64 result = t / (i64)n.value;
@@ -262 +262 @@
     }
 
     /// Mod by a fixed. Must not have n == 0. Result has the same sign as n.
-    CFixed operator%(CFixed n) const
+    CFixed operator%(const CFixed&  n) const
     {
         T t = value % n.value;
         if (n.value > 0 && t < 0)
@@ -279 +279 @@
      * Multiply by a CFixed. Likely to overflow if both numbers are large,
      * so we use an ugly name instead of operator* to make it obvious.
      */
-    CFixed Multiply(CFixed n) const
+    CFixed Multiply(const CFixed& n) const
     {
         i64 t = (i64)value * (i64)n.value;
         t >>= fract_bits;
@@ -299 +299 @@
     /**
      * Compute this*m/d. Must not have d == 0. Won't overflow if the result can be represented as a CFixed.
      */
-    CFixed MulDiv(CFixed m, CFixed d) const
+    CFixed MulDiv(const CFixed& m, const CFixed& d) const
     {
         i64 t = ((i64)value * (i64)m.value) / (i64)d.value;
         CheckCastOverflow(t, T, L"Overflow in CFixed::Multiply(CFixed n)", L"Underflow in CFixed::Multiply(CFixed n)")

source/tools/atlas/GameInterface/Brushes.cpp

@@ -52 +52 @@
         --max_j_inclusive;
     }
 
-    void ProcessTile(ssize_t i, ssize_t j)
+    void ProcessTile(const ssize_t i, const ssize_t j)
     {
         ssize_t i0, j0;
         m_Brush->GetBottomLeft(i0, j0);

source/renderer/TerrainOverlay.h

@@ -123 +123 @@
      * @param i  <i>i</i> coordinate of tile being processed
      * @param j  <i>j</i> coordinate of tile being processed
      */
-    virtual void ProcessTile(ssize_t i, ssize_t j) = 0;
+    virtual void ProcessTile(const ssize_t i, const ssize_t j) = 0;
 
     /**
      * Draw a filled quad on top of the current tile.

source/simulation2/helpers/Geometry.h

@@ -47 +47 @@
  * @return true if @p point is inside the square with rotated X axis unit vector @p u and rotated Z axis unit vector @p v,
  * and half dimensions specified by @p halfSizes.
  */
-bool PointIsInSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
+bool PointIsInSquare(const CFixedVector2D& point, const CFixedVector2D& u, const CFixedVector2D& v, const CFixedVector2D& halfSize);
 
-CFixedVector2D GetHalfBoundingBox(CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
+CFixedVector2D GetHalfBoundingBox(const CFixedVector2D& u, const CFixedVector2D& v, const CFixedVector2D& halfSize);
 
-fixed DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
+fixed DistanceToSquare(const CFixedVector2D& point, const CFixedVector2D& u, const CFixedVector2D& v, const CFixedVector2D& halfSize);
 
 /**
  * Given a circle of radius @p radius, and a chord of length @p chordLength on this circle, computes the central angle formed by 
@@ -75 +75 @@
  * @return point that is closest to @p point on the edge of the square specified by orientation unit vectors @p u and @p v and half
  *  dimensions @p halfSize, relative to the center of the square
  */
-CFixedVector2D NearestPointOnSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
+CFixedVector2D NearestPointOnSquare(const CFixedVector2D& point, const CFixedVector2D& u, const CFixedVector2D& v, const CFixedVector2D& halfSize);
 
-bool TestRaySquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
+bool TestRaySquare(const CFixedVector2D&  a, const CFixedVector2D&  b, const CFixedVector2D& u, const CFixedVector2D& v, const CFixedVector2D& halfSize);
 
-bool TestRayAASquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D halfSize);
+bool TestRayAASquare(const CFixedVector2D&  a, const CFixedVector2D& b, const CFixedVector2D& halfSize);
 
 bool TestSquareSquare(
-        CFixedVector2D c0, CFixedVector2D u0, CFixedVector2D v0, CFixedVector2D halfSize0,
-        CFixedVector2D c1, CFixedVector2D u1, CFixedVector2D v1, CFixedVector2D halfSize1);
+        const CFixedVector2D&  c0, const CFixedVector2D&  u0, const CFixedVector2D&   v0, const CFixedVector2D&   halfSize0,
+        const CFixedVector2D&   c1, const CFixedVector2D&   u1, const CFixedVector2D&   v1, const CFixedVector2D&   halfSize1);
 
 } // namespace
-
 #endif // INCLUDED_HELPER_GEOMETRY

source/simulation2/helpers/Spatial.h

@@ -72 +72 @@
         return !(*this == rhs);
     }
 
-    void Reset(entity_pos_t maxX, entity_pos_t maxZ, entity_pos_t divisionSize)
+    void Reset(const entity_pos_t maxX, const entity_pos_t maxZ, const entity_pos_t divisionSize)
     {
         m_DivisionSize = divisionSize;
         m_DivisionsW = (maxX / m_DivisionSize).ToInt_RoundToInfinity();
@@ -85 +85 @@
      * Add an item with the given 'to' size.
      * The item must not already be present.
      */
-    void Add(T item, CFixedVector2D toMin, CFixedVector2D toMax)
+    void Add(const T& item, const CFixedVector2D& toMin,  const CFixedVector2D& toMax)
     {
         ENSURE(toMin.X <= toMax.X && toMin.Y <= toMax.Y);
 
-        u32 i0 = GetI0(toMin.X);
-        u32 j0 = GetJ0(toMin.Y);
-        u32 i1 = GetI1(toMax.X);
-        u32 j1 = GetJ1(toMax.Y);
+        const u32 i0 = GetI0(toMin.X);
+        const u32 j0 = GetJ0(toMin.Y);
+        const u32 i1 = GetI1(toMax.X);
+        const u32 j1 = GetJ1(toMax.Y);
         for (u32 j = j0; j <= j1; ++j)
         {
             for (u32 i = i0; i <= i1; ++i)
@@ -108 +108 @@
      * The item should already be present.
      * The size must match the size that was last used when adding the item.
      */
-    void Remove(T item, CFixedVector2D fromMin, CFixedVector2D fromMax)
+    void Remove(const T& item,  const CFixedVector2D& fromMin,  const CFixedVector2D& fromMax)
     {
         ENSURE(fromMin.X <= fromMax.X && fromMin.Y <= fromMax.Y);
 
@@ -139 +139 @@
     /**
      * Equivalent to Remove() then Add(), but potentially faster.
      */
-    void Move(T item, CFixedVector2D fromMin, CFixedVector2D fromMax, CFixedVector2D toMin, CFixedVector2D toMax)
+    void Move(const T& item,  const CFixedVector2D& fromMin,  const CFixedVector2D& fromMax,  const CFixedVector2D& toMin,  const CFixedVector2D& toMax)
     {
         // Skip the work if we're staying in the same divisions
         if (GetIndex0(fromMin) == GetIndex0(toMin) && GetIndex1(fromMax) == GetIndex1(toMax))
@@ -153 +153 @@
      * Convenience function for Add() of individual points.
      * (Note that points on a boundary may occupy multiple divisions.)
      */
-    void Add(T item, CFixedVector2D to)
+    void Add(const T& item,  const CFixedVector2D& to)
     {
         Add(item, to, to);
     }
@@ -161 +161 @@
     /**
      * Convenience function for Remove() of individual points.
      */
-    void Remove(T item, CFixedVector2D from)
+    void Remove(const T& item, const CFixedVector2D& from)
     {
         Remove(item, from, from);
     }
@@ -169 +169 @@
     /**
      * Convenience function for Move() of individual points.
      */
-    void Move(T item, CFixedVector2D from, CFixedVector2D to)
+    void Move(const T& item,  const CFixedVector2D& from,  const CFixedVector2D& to)
     {
         Move(item, from, from, to, to);
     }
@@ -178 +178 @@
      * Returns a sorted list of unique items that includes all items
      * within the given axis-aligned square range.
      */
-    std::vector<T> GetInRange(CFixedVector2D posMin, CFixedVector2D posMax)
+    void GetInRange(const CFixedVector2D& posMin, const CFixedVector2D& posMax, std::vector<T> &ret) const
     {
-        std::vector<T> ret;
-
         ENSURE(posMin.X <= posMax.X && posMin.Y <= posMax.Y);
 
-        u32 i0 = GetI0(posMin.X);
-        u32 j0 = GetJ0(posMin.Y);
-        u32 i1 = GetI1(posMax.X);
-        u32 j1 = GetJ1(posMax.Y);
-        for (u32 j = j0; j <= j1; ++j)
+        const u32 i0 = GetI0(posMin.X);
+        const u32 j0 = GetJ0(posMin.Y);
+        const u32 i1 = GetI1(posMax.X);
+        const u32 j1 = GetJ1(posMax.Y);
+
+        ret.reserve((i1 - i0)*(j1 - j0)*4);
+        for (u32 j = j0; j <= j1; j++)
         {
-            for (u32 i = i0; i <= i1; ++i)
+            for (u32 i = i0; i <= i1; i++)
             {
-                std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
+                const std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
                 ret.insert(ret.end(), div.begin(), div.end());
+
             }
         }
 
@@ -201 +202 @@
         std::sort(ret.begin(), ret.end());
         ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
 
-        return ret;
     }
 
     /**
      * Returns a sorted list of unique items that includes all items
      * within the given circular distance of the given point.
      */
-    std::vector<T> GetNear(CFixedVector2D pos, entity_pos_t range)
+    void GetNear(const CFixedVector2D& pos, const entity_pos_t range, std::vector<T> &ents) const
     {
         // TODO: be cleverer and return a circular pattern of divisions,
         // not this square over-approximation
 
-        return GetInRange(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range));
+        return GetInRange(pos - CFixedVector2D(range, range), pos + CFixedVector2D(range, range), ents);
     }
 
 private:
@@ -221 +221 @@
     // (avoiding out-of-bounds accesses, and rounding correctly so that
     // points precisely between divisions are counted in both):
 
-    u32 GetI0(entity_pos_t x)
+    u32 GetI0(const entity_pos_t x) const
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsW-1);
     }
 
-    u32 GetJ0(entity_pos_t z)
+    u32 GetJ0(const entity_pos_t z) const
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsH-1);
     }
 
-    u32 GetI1(entity_pos_t x)
+    u32 GetI1(const entity_pos_t x) const
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsW-1);
     }
 
-    u32 GetJ1(entity_pos_t z)
+    u32 GetJ1(const entity_pos_t z) const
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsH-1);
     }
 
-    u32 GetIndex0(CFixedVector2D pos)
+    u32 GetIndex0(const CFixedVector2D& pos) const 
     {
         return GetI0(pos.X) + GetJ0(pos.Y)*m_DivisionsW;
     }
 
-    u32 GetIndex1(CFixedVector2D pos)
+    u32 GetIndex1(const CFixedVector2D& pos) const
     {
         return GetI1(pos.X) + GetJ1(pos.Y)*m_DivisionsW;
     }

source/simulation2/helpers/Grid.h

@@ -80 +80 @@
             memset(m_Data, 0, m_W*m_H*sizeof(T));
     }
 
-    void set(int i, int j, const T& value)
+    void set(const int i, const int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         m_Data[j*m_W + i] = value;
     }
+    
+    void add(const int i, const int j, T val) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        m_Data[j*m_W + i] += val;
+    }
+    void getPtr(const int i, const int j) 
+    {
+#if GRID_BOUNDS_DEBUG
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
+#endif
+        return m_Data[j*m_W + i];
+    }
 
-    T& get(int i, int j) const
+    T& get(const int i, const int j) const
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -113 +128 @@
 
     enum { BucketBits = 4, BucketSize = 1 << BucketBits };
 
-    T* GetBucket(int i, int j)
+    T* GetBucket(const int i, const int j)
     {
-        size_t b = (j >> BucketBits) * m_BW + (i >> BucketBits);
+        const size_t b = (j >> BucketBits) * m_BW + (i >> BucketBits);
         if (!m_Data[b])
         {
-            m_Data[b] = new T[BucketSize*BucketSize];
+            if (m_Reserve.empty())
+            {               
+                m_Data[b] = new T[BucketSize*BucketSize];
+            }
+            else
+            {
+                m_Data[b] = m_Reserve.back();
+                m_Reserve.pop_back();
+            }
             memset(m_Data[b], 0, BucketSize*BucketSize*sizeof(T));
         }
         return m_Data[b];
@@ -134 +157 @@
 
         m_Data = new T*[m_BW*m_BH];
         memset(m_Data, 0, m_BW*m_BH*sizeof(T*));
+
     }
 
     ~SparseGrid()
-    {
-        reset();
+    {       
+        for (size_t i = 0; i < (size_t)(m_BW*m_BH); ++i)
+            delete[] m_Data[i];
         delete[] m_Data;
     }
 
     void reset()
-    {
+    {       
         for (size_t i = 0; i < (size_t)(m_BW*m_BH); ++i)
-            delete[] m_Data[i];
+        {           
+            if (m_Data[i])
+            {
+                m_Reserve.push_back(m_Data[i]);
+            }
+        }
 
         memset(m_Data, 0, m_BW*m_BH*sizeof(T*));
     }
 
-    void set(int i, int j, const T& value)
+    void set(const int i, const int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -158 +188 @@
         GetBucket(i, j)[(j % BucketSize)*BucketSize + (i % BucketSize)] = value;
     }
 
-    T& get(int i, int j)
+    T& get(const int i, const int j)
     {
 #if GRID_BOUNDS_DEBUG
         ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
@@ -169 +199 @@
     u16 m_W, m_H;
     u16 m_BW, m_BH;
     T** m_Data;
+    std::deque < T* > m_Reserve;
 
     size_t m_DirtyID; // if this is < the id maintained by ICmpObstructionManager then it needs to be updated
 };

source/simulation2/helpers/Geometry.cpp

@@ -25 +25 @@
 
 // TODO: all of these things could be optimised quite easily
 
-bool Geometry::PointIsInSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+bool Geometry::PointIsInSquare(const CFixedVector2D& point, const CFixedVector2D&  u, const CFixedVector2D&  v, const CFixedVector2D&  halfSize)
 {
-    fixed du = point.Dot(u);
+    const fixed du = point.Dot(u);
     if (-halfSize.X <= du && du <= halfSize.X)
     {
-        fixed dv = point.Dot(v);
+        const fixed dv = point.Dot(v);
         if (-halfSize.Y <= dv && dv <= halfSize.Y)
             return true;
     }
     return false;
 }
 
-CFixedVector2D Geometry::GetHalfBoundingBox(CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+CFixedVector2D Geometry::GetHalfBoundingBox(const CFixedVector2D&  u, const CFixedVector2D&  v, const CFixedVector2D&  halfSize)
 {
     return CFixedVector2D(
         u.X.Multiply(halfSize.X).Absolute() + v.X.Multiply(halfSize.Y).Absolute(),
@@ -50 +50 @@
     return acosf(1.f - SQR(chordLength)/(2.f*SQR(radius))); // cfr. law of cosines
 }
 
-fixed Geometry::DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+fixed Geometry::DistanceToSquare(const CFixedVector2D& point, const CFixedVector2D&  u, const CFixedVector2D&  v, const CFixedVector2D&  halfSize)
 {
     /*
      * Relative to its own coordinate system, we have a square like:
@@ -79 +79 @@
      */
 
     // du, dv are the location of the point in the square's coordinate system
-    fixed du = point.Dot(u);
-    fixed dv = point.Dot(v);
+    const fixed du = point.Dot(u);
+    const fixed dv = point.Dot(v);
 
-    fixed hw = halfSize.X;
-    fixed hh = halfSize.Y;
+    const fixed hw = halfSize.X;
+    const fixed hh = halfSize.Y;
 
     // TODO: I haven't actually tested this
 
@@ -116 +116 @@
     }
 }
 
-CFixedVector2D Geometry::NearestPointOnSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+CFixedVector2D Geometry::NearestPointOnSquare(const CFixedVector2D&   point, const CFixedVector2D&   u, const CFixedVector2D&   v, const CFixedVector2D&   halfSize)
 {
     /*
      * Relative to its own coordinate system, we have a square like:
@@ -144 +144 @@
      */
 
     // du, dv are the location of the point in the square's coordinate system
-    fixed du = point.Dot(u);
-    fixed dv = point.Dot(v);
+    const fixed du = point.Dot(u);
+    const fixed dv = point.Dot(v);
 
-    fixed hw = halfSize.X;
-    fixed hh = halfSize.Y;
+    const fixed hw = halfSize.X;
+    const fixed hh = halfSize.Y;
 
     if (-hw < du && du < hw) // regions B, G; or regions D, E inside the square
     {
@@ -190 +190 @@
     }
 }
 
-bool Geometry::TestRaySquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+bool Geometry::TestRaySquare(const CFixedVector2D&   a, const CFixedVector2D&   b, const CFixedVector2D&   u, const CFixedVector2D&   v, const CFixedVector2D&   halfSize)
 {
     /*
      * We only consider collisions to be when the ray goes from outside to inside the shape (and possibly out again).
@@ -205 +205 @@
      * (Points on the edge are considered 'inside'.)
      */
 
-    fixed hw = halfSize.X;
-    fixed hh = halfSize.Y;
+    const fixed hw = halfSize.X;
+    const fixed hh = halfSize.Y;
 
-    fixed au = a.Dot(u);
-    fixed av = a.Dot(v);
+    const fixed au = a.Dot(u);
+    const fixed av = a.Dot(v);
 
     if (-hw <= au && au <= hw && -hh <= av && av <= hh)
         return false; // a is inside
 
-    fixed bu = b.Dot(u);
-    fixed bv = b.Dot(v);
+    const fixed bu = b.Dot(u);
+    const fixed bv = b.Dot(v);
 
     if (-hw <= bu && bu <= hw && -hh <= bv && bv <= hh) // TODO: isn't this subsumed by the next checks?
         return true; // a is outside, b is inside
@@ -223 +223 @@
     if ((au < -hw && bu < -hw) || (au > hw && bu > hw) || (av < -hh && bv < -hh) || (av > hh && bv > hh))
         return false; // ab is entirely above/below/side the square
 
-    CFixedVector2D abp = (b - a).Perpendicular();
-    fixed s0 = abp.Dot((u.Multiply(hw) + v.Multiply(hh)) - a);
-    fixed s1 = abp.Dot((u.Multiply(hw) - v.Multiply(hh)) - a);
-    fixed s2 = abp.Dot((-u.Multiply(hw) - v.Multiply(hh)) - a);
-    fixed s3 = abp.Dot((-u.Multiply(hw) + v.Multiply(hh)) - a);
+    const CFixedVector2D abp ((b - a).Perpendicular());
+    const fixed s0 = abp.Dot((u.Multiply(hw) + v.Multiply(hh)) - a);
+    const fixed s1 = abp.Dot((u.Multiply(hw) - v.Multiply(hh)) - a);
+    const fixed s2 = abp.Dot((-u.Multiply(hw) - v.Multiply(hh)) - a);
+    const fixed s3 = abp.Dot((-u.Multiply(hw) + v.Multiply(hh)) - a);
     if (s0.IsZero() || s1.IsZero() || s2.IsZero() || s3.IsZero())
         return true; // ray intersects the corner
 
-    bool sign = (s0 < fixed::Zero());
+    const bool sign = (s0 < fixed::Zero());
     if ((s1 < fixed::Zero()) != sign || (s2 < fixed::Zero()) != sign || (s3 < fixed::Zero()) != sign)
         return true; // ray cuts through the square
 
     return false;
 }
 
-bool Geometry::TestRayAASquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D halfSize)
+bool Geometry::TestRayAASquare(const CFixedVector2D&   a, const CFixedVector2D&   b, const CFixedVector2D&   halfSize)
 {
     // Exactly like TestRaySquare with u=(1,0), v=(0,1)
 
     // Assume the compiler is clever enough to inline and simplify all this
     // (TODO: stop assuming that)
-    CFixedVector2D u (fixed::FromInt(1), fixed::Zero());
-    CFixedVector2D v (fixed::Zero(), fixed::FromInt(1));
+    const CFixedVector2D u (fixed::FromInt(1), fixed::Zero());
+    const CFixedVector2D v (fixed::Zero(), fixed::FromInt(1));
 
-    fixed hw = halfSize.X;
-    fixed hh = halfSize.Y;
+    const fixed hw = halfSize.X;
+    const fixed hh = halfSize.Y;
 
-    fixed au = a.Dot(u);
-    fixed av = a.Dot(v);
+    const fixed au = a.Dot(u);
+    const fixed av = a.Dot(v);
 
     if (-hw <= au && au <= hw && -hh <= av && av <= hh)
         return false; // a is inside
 
-    fixed bu = b.Dot(u);
-    fixed bv = b.Dot(v);
+    const fixed bu = b.Dot(u);
+    const fixed bv = b.Dot(v);
 
     if (-hw <= bu && bu <= hw && -hh <= bv && bv <= hh) // TODO: isn't this subsumed by the next checks?
         return true; // a is outside, b is inside
@@ -265 +265 @@
     if ((au < -hw && bu < -hw) || (au > hw && bu > hw) || (av < -hh && bv < -hh) || (av > hh && bv > hh))
         return false; // ab is entirely above/below/side the square
 
-    CFixedVector2D abp = (b - a).Perpendicular();
-    fixed s0 = abp.Dot((u.Multiply(hw) + v.Multiply(hh)) - a);
-    fixed s1 = abp.Dot((u.Multiply(hw) - v.Multiply(hh)) - a);
-    fixed s2 = abp.Dot((-u.Multiply(hw) - v.Multiply(hh)) - a);
-    fixed s3 = abp.Dot((-u.Multiply(hw) + v.Multiply(hh)) - a);
+    const CFixedVector2D abp ((b - a).Perpendicular());
+    const fixed s0 = abp.Dot((u.Multiply(hw) + v.Multiply(hh)) - a);
+    const fixed s1 = abp.Dot((u.Multiply(hw) - v.Multiply(hh)) - a);
+    const fixed s2 = abp.Dot((-u.Multiply(hw) - v.Multiply(hh)) - a);
+    const fixed s3 = abp.Dot((-u.Multiply(hw) + v.Multiply(hh)) - a);
     if (s0.IsZero() || s1.IsZero() || s2.IsZero() || s3.IsZero())
         return true; // ray intersects the corner
 
-    bool sign = (s0 < fixed::Zero());
+    const bool sign = (s0 < fixed::Zero());
     if ((s1 < fixed::Zero()) != sign || (s2 < fixed::Zero()) != sign || (s3 < fixed::Zero()) != sign)
         return true; // ray cuts through the square
 
@@ -284 +284 @@
  * Separating axis test; returns true if the square defined by u/v/halfSize at the origin
  * is not entirely on the clockwise side of a line in direction 'axis' passing through 'a'
  */
-static bool SquareSAT(CFixedVector2D a, CFixedVector2D axis, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
+static bool SquareSAT(const CFixedVector2D&   a, const CFixedVector2D&   axis, const CFixedVector2D&   u, const CFixedVector2D&   v, const CFixedVector2D&   halfSize)
 {
-    fixed hw = halfSize.X;
-    fixed hh = halfSize.Y;
+    const fixed hw = halfSize.X;
+    const fixed hh = halfSize.Y;
 
-    CFixedVector2D p = axis.Perpendicular();
+    const CFixedVector2D p (axis.Perpendicular());
     if (p.Dot((u.Multiply(hw) + v.Multiply(hh)) - a) <= fixed::Zero())
         return true;
     if (p.Dot((u.Multiply(hw) - v.Multiply(hh)) - a) <= fixed::Zero())
@@ -303 +303 @@
 }
 
 bool Geometry::TestSquareSquare(
-        CFixedVector2D c0, CFixedVector2D u0, CFixedVector2D v0, CFixedVector2D halfSize0,
-        CFixedVector2D c1, CFixedVector2D u1, CFixedVector2D v1, CFixedVector2D halfSize1)
+        const CFixedVector2D&   c0, const CFixedVector2D&   u0, const CFixedVector2D&   v0, const CFixedVector2D&   halfSize0,
+        const CFixedVector2D&   c1, const CFixedVector2D&   u1, const CFixedVector2D&   v1, const CFixedVector2D&   halfSize1)
 {
     // TODO: need to test this carefully
 
-    CFixedVector2D corner0a = c0 + u0.Multiply(halfSize0.X) + v0.Multiply(halfSize0.Y);
-    CFixedVector2D corner0b = c0 - u0.Multiply(halfSize0.X) - v0.Multiply(halfSize0.Y);
-    CFixedVector2D corner1a = c1 + u1.Multiply(halfSize1.X) + v1.Multiply(halfSize1.Y);
-    CFixedVector2D corner1b = c1 - u1.Multiply(halfSize1.X) - v1.Multiply(halfSize1.Y);
+    const CFixedVector2D corner0a ( c0 + u0.Multiply(halfSize0.X) + v0.Multiply(halfSize0.Y));
+    const CFixedVector2D corner0b ( c0 - u0.Multiply(halfSize0.X) - v0.Multiply(halfSize0.Y));
+    const CFixedVector2D corner1a ( c1 + u1.Multiply(halfSize1.X) + v1.Multiply(halfSize1.Y));
+    const CFixedVector2D corner1b ( c1 - u1.Multiply(halfSize1.X) - v1.Multiply(halfSize1.Y));
 
     // Do a SAT test for each square vs each edge of the other square
     if (!SquareSAT(corner0a - c1, -u0, u1, v1, halfSize1))

source/simulation2/serialization/SerializeTemplates.h

@@ -86 +86 @@
         }
     }
 };
-
 // We have to order the map before serializing to make things consistent
 template<typename KS, typename VS>
 struct SerializeUnorderedMap

source/simulation2/system/InterfaceScripted.h

@@ -61 +61 @@
         2, \
         JSPROP_ENUMERATE|JSPROP_READONLY|JSPROP_PERMANENT },
 
+
 #define DEFINE_INTERFACE_METHOD_3(scriptname, rettype, classname, methodname, arg1, arg2, arg3) \
     { scriptname, \
         ScriptInterface::callMethod<rettype, arg1, arg2, arg3, &class_##classname, classname, &classname::methodname>, \
@@ -85 +86 @@
         6, \
         JSPROP_ENUMERATE|JSPROP_READONLY|JSPROP_PERMANENT },
 
+
 #endif // INCLUDED_INTERFACE_SCRIPTED

source/simulation2/components/ICmpPathfinder.h

@@ -101 +101 @@
      * The waypoints correspond to the centers of horizontally/vertically adjacent tiles
      * along the path.
      */
-    virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& ret) = 0;
+    virtual void ComputePath(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass, Path& ret) = 0;
 
     /**
      * Asynchronous version of ComputePath.
@@ -109 +109 @@
      * Returns a unique non-zero number, which will match the 'ticket' in the result,
      * so callers can recognise each individual request they make.
      */
-    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, entity_id_t notify) = 0;
+    virtual u32 ComputePathAsync(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass, const entity_id_t notify) = 0;
 
     /**
      * If the debug overlay is enabled, render the path that will computed by ComputePath.
      */
-    virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass) = 0;
+    virtual void SetDebugPath(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass) = 0;
 
     /**
      * Compute a precise path from the given point to the goal, and return the set of waypoints.
@@ -122 +122 @@
      * a unit of radius 'r' will be able to follow the path with no collisions.
      * The path is restricted to a box of radius 'range' from the starting point.
      */
-    virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& ret) = 0;
+    virtual void ComputeShortPath(const IObstructionTestFilter& filter, const entity_pos_t x0, const entity_pos_t z0, const entity_pos_t r, const entity_pos_t range, const Goal& goal, const pass_class_t passClass, Path& ret) = 0;
 
     /**
      * Asynchronous version of ComputeShortPath (using ControlGroupObstructionFilter).
@@ -130 +130 @@
      * Returns a unique non-zero number, which will match the 'ticket' in the result,
      * so callers can recognise each individual request they make.
      */
-    virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, bool avoidMovingUnits, entity_id_t group, entity_id_t notify) = 0;
+    virtual u32 ComputeShortPathAsync(const entity_pos_t x0, const entity_pos_t z0, const entity_pos_t r, const entity_pos_t range, const Goal& goal, const pass_class_t passClass, const bool avoidMovingUnits, const entity_id_t controller, const entity_id_t notify) = 0;
 
     /**
      * Find the speed factor (typically around 1.0) for a unit of the given cost class
      * at the given position.
      */
-    virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, cost_class_t costClass) = 0;
+    virtual fixed GetMovementSpeed( const entity_pos_t x0, const entity_pos_t z0,  const cost_class_t costClass)  = 0;
 
     /**
      * Returns the coordinates of the point on the goal that is closest to pos in a straight line.
      */
-    virtual CFixedVector2D GetNearestPointOnGoal(CFixedVector2D pos, const Goal& goal) = 0;
+    virtual CFixedVector2D GetNearestPointOnGoal(const CFixedVector2D& pos, const Goal& goal) const = 0;
 
     /**
      * Check whether the given movement line is valid and doesn't hit any obstructions

source/simulation2/components/ICmpRangeManager.h

@@ -196 +196 @@
         /**
          * Returns whether the given vertex is visible (i.e. is within a unit's LOS).
          */
-        inline bool IsVisible(ssize_t i, ssize_t j)
+        inline bool IsVisible(const ssize_t i, const ssize_t j) const
         {
             if (!(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide))
                 return false;
@@ -211 +211 @@
         /**
          * Returns whether the given vertex is explored (i.e. was (or still is) within a unit's LOS).
          */
-        inline bool IsExplored(ssize_t i, ssize_t j)
+        inline bool IsExplored(const ssize_t i, const ssize_t j) const
         {
             if (!(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide))
                 return false;
@@ -227 +227 @@
          * Returns whether the given vertex is visible (i.e. is within a unit's LOS).
          * i and j must be in the range [0, verticesPerSide), else behaviour is undefined.
          */
-        inline bool IsVisible_UncheckedRange(ssize_t i, ssize_t j)
+        inline bool IsVisible_UncheckedRange(const ssize_t i, const ssize_t j) const
         {
 #ifndef NDEBUG
             ENSURE(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide);
@@ -243 +243 @@
          * Returns whether the given vertex is explored (i.e. was (or still is) within a unit's LOS).
          * i and j must be in the range [0, verticesPerSide), else behaviour is undefined.
          */
-        inline bool IsExplored_UncheckedRange(ssize_t i, ssize_t j)
+        inline bool IsExplored_UncheckedRange(const ssize_t i, const ssize_t j) const
         {
 #ifndef NDEBUG
             ENSURE(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide);
@@ -275 +275 @@
      * TODO: This is a hack to allow preview entities in FoW to return fogged instead of hidden,
      *  see http://trac.wildfiregames.com/ticket/958
      */
-    virtual ELosVisibility GetLosVisibility(entity_id_t ent, player_id_t player, bool forceRetainInFog = false) = 0;
+    virtual ELosVisibility GetLosVisibility(const entity_id_t ent, const player_id_t player, const bool forceRetainInFog = false) = 0;
 
     /**
      * GetLosVisibility wrapped for script calls.
@@ -287 +287 @@
      * Set whether the whole map should be made visible to the given player.
      * If player is -1, the map will be made visible to all players.
      */
-    virtual void SetLosRevealAll(player_id_t player, bool enabled) = 0;
+    virtual void SetLosRevealAll(const player_id_t player, const bool enabled) = 0;
 
     /**
      * Returns whether the whole map has been made visible to the given player.
      */
-    virtual bool GetLosRevealAll(player_id_t player) = 0;
+    virtual bool GetLosRevealAll(const player_id_t player) = 0;
 
     /**
      * Set the LOS to be restricted to a circular map.
@@ -312 +312 @@
     /**
      * Returns shared LOS mask for player.
      */
-    virtual u32 GetSharedLosMask(player_id_t player) = 0;
+    virtual u32 GetSharedLosMask(const player_id_t player) = 0;
 
     /**
      * Get percent map explored statistics for specified player.
      */
-    virtual i32 GetPercentMapExplored(player_id_t player) = 0;
+    virtual i32 GetPercentMapExplored(const player_id_t player) = 0;
 
 
     /**

source/simulation2/components/CCmpPosition.cpp

@@ -419 +419 @@
         {
             const CMessageInterpolate& msgData = static_cast<const CMessageInterpolate&> (msg);
 
-            float rotY = m_RotY.ToFloat();
+            const float rotY = m_RotY.ToFloat();
             float delta = rotY - m_InterpolatedRotY;
-            // Wrap delta to -M_PI..M_PI
-            delta = fmodf(delta + (float)M_PI, 2*(float)M_PI); // range -2PI..2PI
-            if (delta < 0) delta += 2*(float)M_PI; // range 0..2PI
-            delta -= (float)M_PI; // range -M_PI..M_PI
-            // Clamp to max rate
-            float deltaClamped = clamp(delta, -m_RotYSpeed*msgData.deltaSimTime, +m_RotYSpeed*msgData.deltaSimTime);
-            // Calculate new orientation, in a peculiar way in order to make sure the
-            // result gets close to m_orientation (rather than being n*2*M_PI out)
-            m_InterpolatedRotY = rotY + deltaClamped - delta;
+            if (delta != 0.){
+                // Wrap delta to -M_PI..M_PI
+                delta = fmodf(delta + (float)M_PI, 2*(float)M_PI); // range -2PI..2PI
+                if (delta < 0) delta += 2*(float)M_PI; // range 0..2PI
+                delta -= (float)M_PI; // range -M_PI..M_PI
+                // Clamp to max rate
+                const float deltaClamped = clamp(delta, -m_RotYSpeed*msgData.deltaSimTime, +m_RotYSpeed*msgData.deltaSimTime);
+                // Calculate new orientation, in a peculiar way in order to make sure the
+                // result gets close to m_orientation (rather than being n*2*M_PI out)
+                m_InterpolatedRotY = rotY + deltaClamped - delta;
+            }
 
             break;
         }

source/simulation2/components/CCmpObstructionManager.cpp

@@ -84 +84 @@
         serialize.NumberFixed_Unbounded("r", value.r);
         serialize.NumberU8_Unbounded("flags", value.flags);
         serialize.NumberU32_Unbounded("group", value.group);
-    }
+    };
 };
 
 /**
@@ -107 +107 @@
         serialize.NumberU8_Unbounded("flags", value.flags);
         serialize.NumberU32_Unbounded("group", value.group);
         serialize.NumberU32_Unbounded("group2", value.group2);
-    }
+    };
 };
 
 class CCmpObstructionManager : public ICmpObstructionManager
@@ -116 +116 @@
     static void ClassInit(CComponentManager& componentManager)
     {
         componentManager.SubscribeToMessageType(MT_RenderSubmit); // for debug overlays
-    }
+    };
 
     DEFAULT_COMPONENT_ALLOCATOR(ObstructionManager)
 
@@ -517 +517 @@
     /**
      * Return whether the given point is within the world bounds by at least r
      */
-    bool IsInWorld(entity_pos_t x, entity_pos_t z, entity_pos_t r)
+    inline bool IsInWorld(const entity_pos_t x, const entity_pos_t z, const entity_pos_t r) const
     {
         return (m_WorldX0+r <= x && x <= m_WorldX1-r && m_WorldZ0+r <= z && z <= m_WorldZ1-r);
     }
@@ -525 +525 @@
     /**
      * Return whether the given point is within the world bounds
      */
-    bool IsInWorld(CFixedVector2D p)
+    inline bool IsInWorld(const CFixedVector2D& p) const
     {
         return (m_WorldX0 <= p.X && p.X <= m_WorldX1 && m_WorldZ0 <= p.Y && p.Y <= m_WorldZ1);
     }
@@ -541 +541 @@
     if (!IsInWorld(x0, z0, r) || !IsInWorld(x1, z1, r))
         return true;
 
-    CFixedVector2D posMin (std::min(x0, x1) - r, std::min(z0, z1) - r);
-    CFixedVector2D posMax (std::max(x0, x1) + r, std::max(z0, z1) + r);
-
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(posMin, posMax);
-    for (size_t i = 0; i < unitShapes.size(); ++i)
+    const CFixedVector2D posMin (std::min(x0, x1) - r, std::min(z0, z1) - r);
+    const CFixedVector2D posMax (std::max(x0, x1) + r, std::max(z0, z1) + r);
     {
-        std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
-        ENSURE(it != m_UnitShapes.end());
+        std::vector<u32> unitShapes;
+        m_UnitSubdivision.GetInRange(posMin, posMax, unitShapes);
+        const std::vector<u32>::iterator itEnd = unitShapes.end();
+        for (std::vector<u32>::iterator itShape = unitShapes.begin(); itShape != itEnd; ++itShape)
+        {
+            //std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
+            std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(*itShape);
+            ENSURE(it != m_UnitShapes.end());
 
-        if (!filter.TestShape(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, INVALID_ENTITY))
-            continue;
+            if (!filter.TestShape(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, INVALID_ENTITY))
+                continue;
 
-        CFixedVector2D center(it->second.x, it->second.z);
-        CFixedVector2D halfSize(it->second.r + r, it->second.r + r);
-        if (Geometry::TestRayAASquare(CFixedVector2D(x0, z0) - center, CFixedVector2D(x1, z1) - center, halfSize))
-            return true;
+            const CFixedVector2D center(it->second.x, it->second.z);
+            const CFixedVector2D halfSize(it->second.r + r, it->second.r + r);
+            if (Geometry::TestRayAASquare(CFixedVector2D(x0, z0) - center, CFixedVector2D(x1, z1) - center, halfSize))
+                return true;
+        }       
     }
-
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(posMin, posMax);
-    for (size_t i = 0; i < staticShapes.size(); ++i)
     {
-        std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
-        ENSURE(it != m_StaticShapes.end());
+        std::vector<u32> staticShapes;
+        m_StaticSubdivision.GetInRange(posMin, posMax, staticShapes);
+        const std::vector<u32>::iterator itEnd = staticShapes.end();
+        for (std::vector<u32>::iterator itShape = staticShapes.begin(); itShape != itEnd; ++itShape)
+        {
+            std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(*itShape);
+            ENSURE(it != m_StaticShapes.end());
 
-        if (!filter.TestShape(STATIC_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, it->second.group2))
-            continue;
+            if (!filter.TestShape(STATIC_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, it->second.group2))
+                continue;
 
-        CFixedVector2D center(it->second.x, it->second.z);
-        CFixedVector2D halfSize(it->second.hw + r, it->second.hh + r);
-        if (Geometry::TestRaySquare(CFixedVector2D(x0, z0) - center, CFixedVector2D(x1, z1) - center, it->second.u, it->second.v, halfSize))
-            return true;
+            const CFixedVector2D center(it->second.x, it->second.z);
+            const CFixedVector2D halfSize(it->second.hw + r, it->second.hh + r);
+            if (Geometry::TestRaySquare(CFixedVector2D(x0, z0) - center, CFixedVector2D(x1, z1) - center, it->second.u, it->second.v, halfSize))
+                return true;
+        }   
     }
 
     return false;
@@ -590 +597 @@
 
     fixed s, c;
     sincos_approx(a, s, c);
-    CFixedVector2D u(c, -s);
-    CFixedVector2D v(s, c);
-    CFixedVector2D center(x, z);
-    CFixedVector2D halfSize(w/2, h/2);
+    const CFixedVector2D u(c, -s);
+    const CFixedVector2D v(s, c);
+    const CFixedVector2D center(x, z);
+    const CFixedVector2D halfSize(w/2, h/2);
 
     // Check that all corners are within the world (which means the whole shape must be)
     if (!IsInWorld(center + u.Multiply(halfSize.X) + v.Multiply(halfSize.Y)) ||
@@ -607 +614 @@
             return true;
     }
 
-    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
+    const std::map<u32, UnitShape>::iterator itUEnd = m_UnitShapes.end();
+    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != itUEnd; ++it)
     {
         if (!filter.TestShape(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, INVALID_ENTITY))
             continue;
@@ -623 +631 @@
         }
     }
 
-    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
+    const std::map<u32, StaticShape>::iterator itSEnd = m_StaticShapes.end();
+    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != itSEnd; ++it)
     {
         if (!filter.TestShape(STATIC_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, it->second.group2))
             continue;
 
-        CFixedVector2D center1(it->second.x, it->second.z);
-        CFixedVector2D halfSize1(it->second.hw, it->second.hh);
+        const CFixedVector2D center1(it->second.x, it->second.z);
+        const CFixedVector2D halfSize1(it->second.hw, it->second.hh);
         if (Geometry::TestSquareSquare(center, u, v, halfSize, center1, it->second.u, it->second.v, halfSize1))
         {
             if (out)
@@ -664 +673 @@
 
     CFixedVector2D center(x, z);
 
-    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
+    const std::map<u32, UnitShape>::iterator itUEnd = m_UnitShapes.end();
+    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != itUEnd; ++it)
     {
         if (!filter.TestShape(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, INVALID_ENTITY))
             continue;
 
-        entity_pos_t r1 = it->second.r;
+        const entity_pos_t r1 = it->second.r;
 
         if (!(it->second.x + r1 < x - r || it->second.x - r1 > x + r || it->second.z + r1 < z - r || it->second.z - r1 > z + r))
         {
@@ -680 +690 @@
         }
     }
 
-    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
+    const std::map<u32, StaticShape>::iterator itSEnd = m_StaticShapes.end();
+    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != itSEnd; ++it)
     {
         if (!filter.TestShape(STATIC_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, it->second.group2))
             continue;
 
-        CFixedVector2D center1(it->second.x, it->second.z);
+        const CFixedVector2D center1(it->second.x, it->second.z);
         if (Geometry::PointIsInSquare(center1 - center, it->second.u, it->second.v, CFixedVector2D(it->second.hw + r, it->second.hh + r)))
         {
             if (out)
@@ -750 +761 @@
     // so we need to expand by at least 1/sqrt(2) of a tile
     entity_pos_t expandFoundation = (entity_pos_t::FromInt(TERRAIN_TILE_SIZE) * 3) / 4;
 
-    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
+    const std::map<u32, StaticShape>::iterator itSEnd = m_StaticShapes.end();
+    for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != itSEnd; ++it)
     {
         CFixedVector2D center(it->second.x, it->second.z);
 
@@ -776 +788 @@
 
         if (it->second.flags & FLAG_BLOCK_FOUNDATION)
         {
-            CFixedVector2D halfSize(it->second.hw + expandFoundation, it->second.hh + expandFoundation);
-            CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(it->second.u, it->second.v, halfSize);
+            const CFixedVector2D halfSize(it->second.hw + expandFoundation, it->second.hh + expandFoundation);
+            const CFixedVector2D halfBound(Geometry::GetHalfBoundingBox(it->second.u, it->second.v, halfSize));
 
             u16 i0, j0, i1, j1;
             NearestTile(center.X - halfBound.X, center.Y - halfBound.Y, i0, j0, grid.m_W, grid.m_H);
@@ -795 +807 @@
         }
     }
 
-    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
+    const std::map<u32, UnitShape>::iterator itUEnd = m_UnitShapes.end();
+    for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != itUEnd; ++it)
     {
-        CFixedVector2D center(it->second.x, it->second.z);
+        const CFixedVector2D center(it->second.x, it->second.z);
 
         if (it->second.flags & FLAG_BLOCK_PATHFINDING)
         {
@@ -813 +826 @@
 
         if (it->second.flags & FLAG_BLOCK_FOUNDATION)
         {
-            entity_pos_t r = it->second.r + expandFoundation;
+            const entity_pos_t r = it->second.r + expandFoundation;
 
             u16 i0, j0, i1, j1;
             NearestTile(center.X - r, center.Y - r, i0, j0, grid.m_W, grid.m_H);
@@ -880 +893 @@
 
     ENSURE(x0 <= x1 && z0 <= z1);
 
-    std::vector<u32> unitShapes = m_UnitSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
-    for (size_t i = 0; i < unitShapes.size(); ++i)
+    std::vector<u32> unitShapes;
+    m_UnitSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1), unitShapes);
+    const std::vector<u32>::iterator  itUEnd = unitShapes.end();
+    for (std::vector<u32>::iterator itShape = unitShapes.begin(); itShape != itUEnd; ++itShape)
     {
-        std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
+        std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(*itShape);
         ENSURE(it != m_UnitShapes.end());
 
         if (!filter.TestShape(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, INVALID_ENTITY))
@@ -901 +916 @@
         squares.push_back(s);
     }
 
-    std::vector<u32> staticShapes = m_StaticSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1));
-    for (size_t i = 0; i < staticShapes.size(); ++i)
+    std::vector<u32> staticShapes;
+    m_StaticSubdivision.GetInRange(CFixedVector2D(x0, z0), CFixedVector2D(x1, z1), staticShapes);
+    const std::vector<u32>::iterator itSEnd = staticShapes.end();
+    for (std::vector<u32>::iterator itShape = staticShapes.begin(); itShape != itSEnd; ++itShape)
     {
-        std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
+        //std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
+        std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(*itShape);
         ENSURE(it != m_StaticShapes.end());
 
         if (!filter.TestShape(STATIC_INDEX_TO_TAG(it->first), it->second.flags, it->second.group, it->second.group2))
@@ -981 +999 @@
                 (m_WorldX1-m_WorldX0).ToFloat(), (m_WorldZ1-m_WorldZ0).ToFloat(),
                 0, m_DebugOverlayLines.back(), true);
 
-        for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
         {
-            m_DebugOverlayLines.push_back(SOverlayLine());
-            m_DebugOverlayLines.back().m_Color = ((it->second.flags & FLAG_MOVING) ? movingColour : defaultColour);
-            SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.r.ToFloat()*2, it->second.r.ToFloat()*2, 0, m_DebugOverlayLines.back(), true);
+            const std::map<u32, UnitShape>::iterator itUEnd = m_UnitShapes.end();
+            for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != itUEnd; ++it)
+            {
+                m_DebugOverlayLines.push_back(SOverlayLine());
+                m_DebugOverlayLines.back().m_Color = ((it->second.flags & FLAG_MOVING) ? movingColour : defaultColour);
+                SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.r.ToFloat()*2, it->second.r.ToFloat()*2, 0, m_DebugOverlayLines.back(), true);
+            }
         }
-
-        for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
         {
-            m_DebugOverlayLines.push_back(SOverlayLine());
-            m_DebugOverlayLines.back().m_Color = defaultColour;
-            float a = atan2f(it->second.v.X.ToFloat(), it->second.v.Y.ToFloat());
-            SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.hw.ToFloat()*2, it->second.hh.ToFloat()*2, a, m_DebugOverlayLines.back(), true);
+            const std::map<u32, StaticShape>::iterator itSEnd = m_StaticShapes.end();
+            for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != itSEnd; ++it)
+            {
+                m_DebugOverlayLines.push_back(SOverlayLine());
+                m_DebugOverlayLines.back().m_Color = defaultColour;
+                float a = atan2f(it->second.v.X.ToFloat(), it->second.v.Y.ToFloat());
+                SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.hw.ToFloat()*2, it->second.hh.ToFloat()*2, a, m_DebugOverlayLines.back(), true);
+            }
         }
-
         m_DebugOverlayDirty = false;
     }
 

source/simulation2/components/CCmpUnitMotion.cpp

@@ -521 +521 @@
     /**
      * Do the per-turn movement and other updates.
      */
-    void Move(fixed dt);
+    void Move(const fixed dt);
 
     /**
      * Decide whether to approximate the given range from a square target as a circle,
      * rather than as a square.
      */
-    bool ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t hw, entity_pos_t hh, entity_pos_t circleRadius);
+    bool ShouldTreatTargetAsCircle(const entity_pos_t range, const entity_pos_t hw, const entity_pos_t hh, const entity_pos_t circleRadius);
 
     /**
      * Computes the current location of our target entity (plus offset).
@@ -539 +539 @@
      * Attempts to replace the current path with a straight line to the target
      * entity, if it's close enough and the route is not obstructed.
      */
-    bool TryGoingStraightToTargetEntity(CFixedVector2D from);
+    bool TryGoingStraightToTargetEntity(const CFixedVector2D&  from);
 
     /**
      * Returns whether the target entity has moved more than minDelta since our
      * last path computations, and we're close enough to it to care.
      */
-    bool CheckTargetMovement(CFixedVector2D from, entity_pos_t minDelta);
+    bool CheckTargetMovement(const CFixedVector2D&  from, const entity_pos_t minDelta);
 
     /**
      * Returns whether the length of the given path, plus the distance from
      * 'from' to the first waypoints, it shorter than minDistance.
      */
-    bool PathIsShort(const ICmpPathfinder::Path& path, CFixedVector2D from, entity_pos_t minDistance);
+    bool PathIsShort(const ICmpPathfinder::Path& path, const CFixedVector2D& from, const entity_pos_t minDistance);
 
     /**
      * Rotate to face towards the target point, given the current pos
      */
-    void FaceTowardsPointFromPos(CFixedVector2D pos, entity_pos_t x, entity_pos_t z);
+    void FaceTowardsPointFromPos(const CFixedVector2D&  pos, const entity_pos_t x, const entity_pos_t z);
 
     /**
      * Returns an appropriate obstruction filter for use with path requests.
@@ -568 +568 @@
      * Might go in a straight line immediately, or might start an asynchronous
      * path request.
      */
-    void BeginPathing(CFixedVector2D from, const ICmpPathfinder::Goal& goal);
+    void BeginPathing(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal);
 
     /**
      * Start an asynchronous long path query.
      */
-    void RequestLongPath(CFixedVector2D from, const ICmpPathfinder::Goal& goal);
+    void RequestLongPath(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal);
 
     /**
      * Start an asynchronous short path query.
      */
-    void RequestShortPath(CFixedVector2D from, const ICmpPathfinder::Goal& goal, bool avoidMovingUnits);
+    void RequestShortPath(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal, bool avoidMovingUnits);
 
     /**
      * Select a next long waypoint, given the current unit position.
@@ -753 +753 @@
     }
 }
 
-void CCmpUnitMotion::Move(fixed dt)
+void CCmpUnitMotion::Move(const fixed dt)
 {
     PROFILE("Move");
 
@@ -802 +802 @@
         if (!cmpPosition || !cmpPosition->IsInWorld())
             return;
 
-        CFixedVector2D initialPos = cmpPosition->GetPosition2D();
+        const CFixedVector2D initialPos (cmpPosition->GetPosition2D());
 
         // If we're chasing a potentially-moving unit and are currently close
         // enough to its current position, and we can head in a straight line
@@ -811 +811 @@
             TryGoingStraightToTargetEntity(initialPos);
 
         // Keep track of the current unit's position during the update
-        CFixedVector2D pos = initialPos;
+        CFixedVector2D pos (initialPos);
 
         // If in formation, run to keep up; otherwise just walk
         // (TODO: support stamina, charging, etc)
@@ -824 +824 @@
         // Find the speed factor of the underlying terrain
         // (We only care about the tile we start on - it doesn't matter if we're moving
         // partially onto a much slower/faster tile)
-        fixed terrainSpeed = cmpPathfinder->GetMovementSpeed(pos.X, pos.Y, m_CostClass);
+        const fixed terrainSpeed = cmpPathfinder->GetMovementSpeed(pos.X, pos.Y, m_CostClass);
 
-        fixed maxSpeed = basicSpeed.Multiply(terrainSpeed);
+        const fixed maxSpeed = basicSpeed.Multiply(terrainSpeed);
 
         bool wasObstructed = false;
 
@@ -841 +841 @@
                 break;
 
             CFixedVector2D target(m_ShortPath.m_Waypoints.back().x, m_ShortPath.m_Waypoints.back().z);
-            CFixedVector2D offset = target - pos;
+            CFixedVector2D offset (target - pos);
 
             // Face towards the target
             if (!offset.IsZero())
@@ -924 +924 @@
             // If we are close to reaching the end of the short path
             // (or have reached it already), try to extend it
 
-            entity_pos_t minDistance = basicSpeed.Multiply(dt) * WAYPOINT_ADVANCE_LOOKAHEAD_TURNS;
+            const entity_pos_t minDistance = basicSpeed.Multiply(dt) * WAYPOINT_ADVANCE_LOOKAHEAD_TURNS;
             if (PathIsShort(m_ShortPath, pos, minDistance))
             {
                 // Start the path extension from the end of this short path
                 // (or our current position if no short path)
-                CFixedVector2D from = pos;
+                CFixedVector2D from (pos);
                 if (!m_ShortPath.m_Waypoints.empty())
                     from = CFixedVector2D(m_ShortPath.m_Waypoints[0].x, m_ShortPath.m_Waypoints[0].z);
 
@@ -1010 +1010 @@
     return true;
 }
 
-bool CCmpUnitMotion::TryGoingStraightToTargetEntity(CFixedVector2D from)
+bool CCmpUnitMotion::TryGoingStraightToTargetEntity(const CFixedVector2D&  from)
 {
     CFixedVector2D targetPos;
     if (!ComputeTargetPosition(targetPos))
@@ -1048 +1048 @@
     return true;
 }
 
-bool CCmpUnitMotion::CheckTargetMovement(CFixedVector2D from, entity_pos_t minDelta)
+bool CCmpUnitMotion::CheckTargetMovement(const CFixedVector2D& from, entity_pos_t minDelta)
 {
     CFixedVector2D targetPos;
     if (!ComputeTargetPosition(targetPos))
@@ -1087 +1087 @@
     return true;
 }
 
-bool CCmpUnitMotion::PathIsShort(const ICmpPathfinder::Path& path, CFixedVector2D from, entity_pos_t minDistance)
+bool CCmpUnitMotion::PathIsShort(const ICmpPathfinder::Path& path, const CFixedVector2D&  from, const entity_pos_t minDistance)
 {
-    CFixedVector2D pos = from;
+    CFixedVector2D pos (from);
     entity_pos_t distLeft = minDistance;
 
-    for (ssize_t i = (ssize_t)path.m_Waypoints.size()-1; i >= 0; --i)
+    const std::vector<ICmpPathfinder::Waypoint>::const_reverse_iterator itEnd = path.m_Waypoints.rend();
+    for (std::vector<ICmpPathfinder::Waypoint>::const_reverse_iterator it = path.m_Waypoints.rbegin(); it != itEnd; ++it)
     {
+        const ICmpPathfinder::Waypoint& waypoint = *it;
         // Check if the next path segment is longer than the requested minimum
-        CFixedVector2D waypoint(path.m_Waypoints[i].x, path.m_Waypoints[i].z);
-        CFixedVector2D delta = waypoint - pos;
+        const CFixedVector2D waypoint_pos(waypoint.x, waypoint.z);
+        const CFixedVector2D delta (waypoint_pos - pos);
         if (delta.CompareLength(distLeft) > 0)
             return false;
 
         // Still short enough - prepare to check the next segment
+        //todo: perf: reuse sqlenth from just above computation.
         distLeft -= delta.Length();
-        pos = waypoint;
+        pos = waypoint_pos;
     }
 
     // Reached the end of the path before exceeding minDistance
     return true;
 }
 
-void CCmpUnitMotion::FaceTowardsPoint(entity_pos_t x, entity_pos_t z)
+void CCmpUnitMotion::FaceTowardsPoint(const entity_pos_t x, const entity_pos_t z)
 {
     CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return;
 
-    CFixedVector2D pos = cmpPosition->GetPosition2D();
+    const CFixedVector2D pos (cmpPosition->GetPosition2D());
     FaceTowardsPointFromPos(pos, x, z);
 }
 
-void CCmpUnitMotion::FaceTowardsPointFromPos(CFixedVector2D pos, entity_pos_t x, entity_pos_t z)
+void CCmpUnitMotion::FaceTowardsPointFromPos(const CFixedVector2D&  pos, const entity_pos_t x, const entity_pos_t z)
 {
     CFixedVector2D target(x, z);
-    CFixedVector2D offset = target - pos;
+    CFixedVector2D offset (target - pos);
     if (!offset.IsZero())
     {
         entity_angle_t angle = atan2_approx(offset.X, offset.Y);
@@ -1147 +1150 @@
 
 
 
-void CCmpUnitMotion::BeginPathing(CFixedVector2D from, const ICmpPathfinder::Goal& goal)
+void CCmpUnitMotion::BeginPathing(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal)
 {
     // Cancel any pending path requests
     m_ExpectedPathTicket = 0;
@@ -1181 +1184 @@
     RequestLongPath(from, goal);
 }
 
-void CCmpUnitMotion::RequestLongPath(CFixedVector2D from, const ICmpPathfinder::Goal& goal)
+void CCmpUnitMotion::RequestLongPath(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal)
 {
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
     if (!cmpPathfinder)
@@ -1192 +1195 @@
     m_ExpectedPathTicket = cmpPathfinder->ComputePathAsync(from.X, from.Y, goal, m_PassClass, m_CostClass, GetEntityId());
 }
 
-void CCmpUnitMotion::RequestShortPath(CFixedVector2D from, const ICmpPathfinder::Goal& goal, bool avoidMovingUnits)
+void CCmpUnitMotion::RequestShortPath(const CFixedVector2D&  from, const ICmpPathfinder::Goal& goal, const bool avoidMovingUnits)
 {
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
     if (!cmpPathfinder)
@@ -1201 +1204 @@
     m_ExpectedPathTicket = cmpPathfinder->ComputeShortPathAsync(from.X, from.Y, m_Radius, SHORT_PATH_SEARCH_RANGE, goal, m_PassClass, avoidMovingUnits, m_TargetEntity, GetEntityId());
 }
 
-bool CCmpUnitMotion::PickNextLongWaypoint(const CFixedVector2D& pos, bool avoidMovingUnits)
+bool CCmpUnitMotion::PickNextLongWaypoint(const CFixedVector2D& pos, const bool avoidMovingUnits)
 {
     // If there's no long path, we can't pick the next waypoint from it
     if (m_LongPath.m_Waypoints.empty())
@@ -1252 +1255 @@
 }
 
 
-bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange)
+bool CCmpUnitMotion::MoveToPointRange(const entity_pos_t x, const entity_pos_t z, const entity_pos_t minRange, const entity_pos_t maxRange)
 {
     PROFILE("MoveToPointRange");
 
@@ -1338 +1341 @@
     return true;
 }
 
-bool CCmpUnitMotion::IsInPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange)
+bool CCmpUnitMotion::IsInPointRange(const entity_pos_t x, const entity_pos_t z, const entity_pos_t minRange, const entity_pos_t maxRange)
 {
     CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return false;
 
-    CFixedVector2D pos = cmpPosition->GetPosition2D();
+    const CFixedVector2D pos (cmpPosition->GetPosition2D());
 
     bool hasObstruction = false;
     CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
@@ -1355 +1358 @@
     if (minRange.IsZero() && maxRange.IsZero() && hasObstruction)
     {
         // Handle the non-ranged mode:
-        CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
-        entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize);
+        const CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
+        const entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize);
 
         // See if we're too close to the target square
         if (distance < minRange)
@@ -1370 +1373 @@
     }
     else
     {
-        entity_pos_t distance = (pos - CFixedVector2D(x, z)).Length();
+        const entity_pos_t distance = (pos - CFixedVector2D(x, z)).Length();
 
         if (distance < minRange)
         {
@@ -1387 +1390 @@
     }
 }
 
-bool CCmpUnitMotion::ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t hw, entity_pos_t hh, entity_pos_t circleRadius)
+bool CCmpUnitMotion::ShouldTreatTargetAsCircle(const entity_pos_t range, const entity_pos_t hw, const entity_pos_t hh, const entity_pos_t circleRadius)
 {
     // Given a square, plus a target range we should reach, the shape at that distance
     // is a round-cornered square which we can approximate as either a circle or as a square.
@@ -1402 +1405 @@
     return (errCircle < errSquare);
 }
 
-bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange)
+bool CCmpUnitMotion::MoveToTargetRange(const entity_id_t target, const entity_pos_t minRange, const entity_pos_t maxRange)
 {
     PROFILE("MoveToTargetRange");
 
@@ -1546 +1549 @@
     }
 }
 
-bool CCmpUnitMotion::IsInTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange)
+bool CCmpUnitMotion::IsInTargetRange(const entity_id_t target, const entity_pos_t minRange, const entity_pos_t maxRange)
 {
     // This function closely mirrors MoveToTargetRange - it needs to return true
     // after that Move has completed
@@ -1612 +1615 @@
     }
 }
 
-void CCmpUnitMotion::MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z)
+void CCmpUnitMotion::MoveToFormationOffset(const entity_id_t target, const entity_pos_t x, const entity_pos_t z)
 {
     CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), target);
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return;
 
-    CFixedVector2D pos = cmpPosition->GetPosition2D();
+    CFixedVector2D pos (cmpPosition->GetPosition2D());
 
     ICmpPathfinder::Goal goal;
     goal.type = ICmpPathfinder::Goal::POINT;

source/simulation2/components/tests/test_Pathfinder.h

@@ -68 +68 @@
         CMapReader* mapReader = new CMapReader(); // it'll call "delete this" itself
 
         LDR_BeginRegistering();
-        mapReader->LoadMap(L"maps/scenarios/Median Oasis.pmp", &terrain, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        mapReader->LoadMap(L"maps/scenarios/Median Oasis 01.pmp", &terrain, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
             &sim2, &sim2.GetSimContext(), -1, false);
         LDR_EndRegistering();
         TS_ASSERT_OK(LDR_NonprogressiveLoad());
@@ -90 +90 @@
             printf("%d: %f %f\n", (int)i, path.m_Waypoints[i].x.ToDouble(), path.m_Waypoints[i].z.ToDouble());
 #endif
 
-        double t = timer_Time();
 
         srand(1234);
+
+        std::vector<ICmpPathfinder::Goal> goals;
+
+        std::vector<entity_pos_t> x0s;
+        std::vector<entity_pos_t> z0s;
         for (size_t j = 0; j < 1024*2; ++j)
         {
             entity_pos_t x0 = entity_pos_t::FromInt(rand() % 512);
@@ -100 +104 @@
             entity_pos_t x1 = x0 + entity_pos_t::FromInt(rand() % 64);
             entity_pos_t z1 = z0 + entity_pos_t::FromInt(rand() % 64);
             ICmpPathfinder::Goal goal = { ICmpPathfinder::Goal::POINT, x1, z1 };
+            x0s.push_back(x0);
+            z0s.push_back(z0);
+            goals.push_back(goal);
+        }
 
-            ICmpPathfinder::Path path;
-            cmp->ComputePath(x0, z0, goal, cmp->GetPassabilityClass("default"), cmp->GetCostClass("default"), path);
+        double t = timer_Time();
+
+        
+        ICmpPathfinder::Path path;
+        for (size_t j = 0; j < 1024*2; ++j)
+        {
+            cmp->ComputePath(x0s[j], z0s[j], goals[j], cmp->GetPassabilityClass("default"), cmp->GetCostClass("default"), path);
         }
 
         t = timer_Time() - t;
-        printf("[%f]", t);
+        printf("\nTestCmpPathfinder ComputePath[%f]", t);
     }
 
     void test_performance_short_DISABLED()
@@ -124 +137 @@
         CmpPtr<ICmpPathfinder> cmpPathfinder(sim2, SYSTEM_ENTITY);
 
         srand(0);
+
         for (size_t i = 0; i < 200; ++i)
         {
             fixed x = fixed::FromFloat(1.5f*range.ToFloat() * rand()/(float)RAND_MAX);
@@ -131 +145 @@
 //          printf("# %f %f\n", x.ToFloat(), z.ToFloat());
             cmpObstructionMan->AddUnitShape(INVALID_ENTITY, x, z, fixed::FromInt(2), 0, INVALID_ENTITY);
         }
+            
+        double t = timer_Time();
 
-        NullObstructionFilter filter;
-        ICmpPathfinder::Goal goal = { ICmpPathfinder::Goal::POINT, range, range };
-        ICmpPathfinder::Path path;
-        cmpPathfinder->ComputeShortPath(filter, range/3, range/3, fixed::FromInt(2), range, goal, 0, path);
-        for (size_t i = 0; i < path.m_Waypoints.size(); ++i)
-            printf("# %d: %f %f\n", (int)i, path.m_Waypoints[i].x.ToFloat(), path.m_Waypoints[i].z.ToFloat());
+        for (size_t j = 0; j < 1024*2; ++j)
+        {
+
+            NullObstructionFilter filter;
+            ICmpPathfinder::Goal goal = { ICmpPathfinder::Goal::POINT, range, range };
+            ICmpPathfinder::Path path;
+
+            cmpPathfinder->ComputeShortPath(filter, range/3, range/3, fixed::FromInt(2), range, goal, 0, path);
+        }
+            
+        t = timer_Time() - t;
+        
+        printf("\nTestCmpPathfinder ComputeShortPath[%f]\n", t);
+        {
+            NullObstructionFilter filter;
+            ICmpPathfinder::Goal goal = { ICmpPathfinder::Goal::POINT, range, range };
+            ICmpPathfinder::Path path;
+
+            cmpPathfinder->ComputeShortPath(filter, range/3, range/3, fixed::FromInt(2), range, goal, 0, path);
+                for (size_t i = 0; i < path.m_Waypoints.size(); ++i)
+                    printf("# %d: %f %f\n", (int)i, path.m_Waypoints[i].x.ToFloat(), path.m_Waypoints[i].z.ToFloat());
+        }
     }
 };

source/simulation2/components/CCmpPathfinder_Vertex.cpp

@@ -63 +63 @@
  * Therefore it must continue to a vertex in the BR quadrant (so this vertex is in
  * *that* vertex's TL quadrant).
  *
- * That lets us significantly reduce the search space by quickly discarding vertexes
+ * That lets us significantly reduce the search space by quickly discarding vertices
  * from the wrong quadrants.
  *
  * (This causes badness if the path starts from inside the shape, so we add some hacks
@@ -82 +82 @@
 static const u8 QUADRANT_ALL = QUADRANT_BLTR|QUADRANT_TLBR;
 
 // A vertex around the corners of an obstruction
-// (paths will be sequences of these vertexes)
+// (paths will be sequences of these vertices)
 struct Vertex
 {
     enum
@@ -118 +118 @@
     fixed c1;
 };
 
-// When computing vertexes to insert into the search graph,
-// add a small delta so that the vertexes of an edge don't get interpreted
+// When computing vertices to insert into the search graph,
+// add a small delta so that the vertices of an edge don't get interpreted
 // as crossing the edge (given minor numerical inaccuracies)
 static const entity_pos_t EDGE_EXPAND_DELTA = entity_pos_t::FromInt(1)/4;
 
@@ -127 +127 @@
  * Check whether a ray from 'a' to 'b' crosses any of the edges.
  * (Edges are one-sided so it's only considered a cross if going from front to back.)
  */
-inline static bool CheckVisibility(CFixedVector2D a, CFixedVector2D b, const std::vector<Edge>& edges)
+inline static bool CheckVisibility(const CFixedVector2D& a, const CFixedVector2D& b, const CFixedVector2D& abn, const std::vector<Edge>& edges)
 {
-    CFixedVector2D abn = (b - a).Perpendicular();
-
+    fixed s;
     // Edges of general non-axis-aligned shapes
-    for (size_t i = 0; i < edges.size(); ++i)
+    const std::vector<Edge>::const_iterator itEnd = edges.end();
+    for (std::vector<Edge>::const_iterator it = edges.begin(); it != itEnd; ++it)
     {
-        CFixedVector2D p0 = edges[i].p0;
-        CFixedVector2D p1 = edges[i].p1;
+        const Edge e = *it;
+        const CFixedVector2D& p0 (e.p0);
 
-        CFixedVector2D d = (p1 - p0).Perpendicular();
+        // The ray is crossing the infinitely-extended edge from in front to behind.
+        // Check the finite edge is crossing the infinitely-extended ray too.
+        // (Given the previous tests, it can only be crossing in one direction.)
+        s = p0.SubAndDot(a, abn);
+        if (s > fixed::Zero())
+            continue;
 
+        const CFixedVector2D& p1 (e.p1);
+
+        s = p1.SubAndDot(a, abn);
+        if (s < fixed::Zero())
+            continue;
+
+        const CFixedVector2D d ((p1 - p0).Perpendicular());
+
         // If 'a' is behind the edge, we can't cross
-        fixed q = (a - p0).Dot(d);
-        if (q < fixed::Zero())
+        s = a.SubAndDot(p0, d);
+        if (s < fixed::Zero())
             continue;
 
         // If 'b' is in front of the edge, we can't cross
-        fixed r = (b - p0).Dot(d);
-        if (r > fixed::Zero())
-            continue;
-
-        // The ray is crossing the infinitely-extended edge from in front to behind.
-        // Check the finite edge is crossing the infinitely-extended ray too.
-        // (Given the previous tests, it can only be crossing in one direction.)
-        fixed s = (p0 - a).Dot(abn);
+        s = b.SubAndDot(p0, d);
         if (s > fixed::Zero())
             continue;
 
-        fixed t = (p1 - a).Dot(abn);
-        if (t < fixed::Zero())
-            continue;
-
         return false;
     }
 
@@ -170 +172 @@
 // (These are specialised versions of the general unaligned edge code.
 // They assume the caller has already excluded edges for which 'a' is
 // on the wrong side.)
-
-inline static bool CheckVisibilityLeft(CFixedVector2D a, CFixedVector2D b, const std::vector<EdgeAA>& edges)
+inline static bool CheckVisibilityLeft(const CFixedVector2D& a, const CFixedVector2D& b, const CFixedVector2D& abn, const std::vector<EdgeAA>& edges)
 {
     if (a.X >= b.X)
         return true;
-
-    CFixedVector2D abn = (b - a).Perpendicular();
-
-    for (size_t i = 0; i < edges.size(); ++i)
+    fixed s;
+    const std::vector<EdgeAA>::const_iterator itEnd = edges.end();
+    for (std::vector<EdgeAA>::const_iterator it = edges.begin(); it != itEnd; ++it)
     {
-        if (b.X < edges[i].p0.X)
-            continue;
-
-        CFixedVector2D p0 (edges[i].p0.X, edges[i].c1);
-        fixed s = (p0 - a).Dot(abn);
-        if (s > fixed::Zero())
-            continue;
-
-        CFixedVector2D p1 (edges[i].p0.X, edges[i].p0.Y);
-        fixed t = (p1 - a).Dot(abn);
-        if (t < fixed::Zero())
-            continue;
-
-        return false;
+        const EdgeAA& e = *it;
+        if ( b.X >= e.p0.X){ // diff line from right
+            s = a.SubFromAndDot(e.p0.X, e.c1, abn);
+            if (s.value <= 0){
+                s = a.SubFromAndDot(e.p0.X, e.p0.Y, abn);
+                if (s.value >= 0){
+                    return false;
+                }
+            }
+        }
     }
 
     return true;
 }
 
-inline static bool CheckVisibilityRight(CFixedVector2D a, CFixedVector2D b, const std::vector<EdgeAA>& edges)
+inline static bool CheckVisibilityRight(const CFixedVector2D& a, const CFixedVector2D& b, const CFixedVector2D& abn,const std::vector<EdgeAA>& edges)
 {
     if (a.X <= b.X)
         return true;
-
-    CFixedVector2D abn = (b - a).Perpendicular();
-
-    for (size_t i = 0; i < edges.size(); ++i)
+    fixed s;
+    const std::vector<EdgeAA>::const_iterator itEnd = edges.end();
+    for (std::vector<EdgeAA>::const_iterator it = edges.begin(); it != itEnd; ++it)
     {
-        if (b.X > edges[i].p0.X)
-            continue;
-
-        CFixedVector2D p0 (edges[i].p0.X, edges[i].c1);
-        fixed s = (p0 - a).Dot(abn);
-        if (s > fixed::Zero())
-            continue;
-
-        CFixedVector2D p1 (edges[i].p0.X, edges[i].p0.Y);
-        fixed t = (p1 - a).Dot(abn);
-        if (t < fixed::Zero())
-            continue;
-
-        return false;
+        const EdgeAA& e = *it;
+        if ( b.X <= e.p0.X){ // diff line from left
+            s = a.SubFromAndDot(e.p0.X, e.c1, abn);
+            if (s.value <= 0){
+                s = a.SubFromAndDot(e.p0.X, e.p0.Y, abn);
+                if (s.value >= 0){
+                    return false;
+                }
+            }
+        }
     }
 
     return true;
 }
 
-inline static bool CheckVisibilityBottom(CFixedVector2D a, CFixedVector2D b, const std::vector<EdgeAA>& edges)
+inline static bool CheckVisibilityBottom(const CFixedVector2D& a, const CFixedVector2D& b, const CFixedVector2D& abn, const std::vector<EdgeAA>& edges)
 {
     if (a.Y >= b.Y)
         return true;
-
-    CFixedVector2D abn = (b - a).Perpendicular();
-
-    for (size_t i = 0; i < edges.size(); ++i)
+    fixed s;
+    const std::vector<EdgeAA>::const_iterator itEnd = edges.end();
+    for (std::vector<EdgeAA>::const_iterator it = edges.begin(); it != itEnd; ++it)
     {
-        if (b.Y < edges[i].p0.Y)
-            continue;
-
-        CFixedVector2D p0 (edges[i].p0.X, edges[i].p0.Y);
-        fixed s = (p0 - a).Dot(abn);
-        if (s > fixed::Zero())
-            continue;
-
-        CFixedVector2D p1 (edges[i].c1, edges[i].p0.Y);
-        fixed t = (p1 - a).Dot(abn);
-        if (t < fixed::Zero())
-            continue;
-
-        return false;
+        const EdgeAA& e = *it;
+        if ( b.Y >= e.p0.Y){ // diff line from top
+            s = a.SubFromAndDot(e.p0.X, e.p0.Y, abn);
+            if (s.value <= 0){
+                s = a.SubFromAndDot(e.c1, e.p0.Y, abn);
+                if (s.value >= 0){
+                    return false;
+                }
+            }
+        }
     }
 
     return true;
 }
 
-inline static bool CheckVisibilityTop(CFixedVector2D a, CFixedVector2D b, const std::vector<EdgeAA>& edges)
+inline static bool CheckVisibilityTop(const CFixedVector2D& a, const CFixedVector2D& b, const CFixedVector2D& abn,const std::vector<EdgeAA>& edges)
 {
     if (a.Y <= b.Y)
         return true;
-
-    CFixedVector2D abn = (b - a).Perpendicular();
-
-    for (size_t i = 0; i < edges.size(); ++i)
+    
+    fixed s;
+    const std::vector<EdgeAA>::const_iterator itEnd = edges.end();
+    for (std::vector<EdgeAA>::const_iterator it = edges.begin(); it != itEnd; ++it)
     {
-        if (b.Y > edges[i].p0.Y)
-            continue;
+        const EdgeAA& e = *it;
+        if ( b.Y <= e.p0.Y){ // diff line from bottom
+            s = a.SubFromAndDot(e.p0.X, e.p0.Y, abn);
+            if (s.value <= 0){
+                s = a.SubFromAndDot(e.c1, e.p0.Y, abn);
+                if (s.value >= 0){
+                    return false;
+                }
+            }
+        }
+    }
 
-        CFixedVector2D p0 (edges[i].p0.X, edges[i].p0.Y);
-        fixed s = (p0 - a).Dot(abn);
-        if (s > fixed::Zero())
-            continue;
 
-        CFixedVector2D p1 (edges[i].c1, edges[i].p0.Y);
-        fixed t = (p1 - a).Dot(abn);
-        if (t < fixed::Zero())
-            continue;
-
-        return false;
-    }
-
     return true;
 }
 
 
-static CFixedVector2D NearestPointOnGoal(CFixedVector2D pos, const CCmpPathfinder::Goal& goal)
+
+static CFixedVector2D NearestPointOnGoal(const CFixedVector2D& pos, const CCmpPathfinder::Goal& goal)
 {
-    CFixedVector2D g(goal.x, goal.z);
+    const CFixedVector2D g(goal.x, goal.z);
 
     switch (goal.type)
     {
@@ -306 +290 @@
 
     case CCmpPathfinder::Goal::SQUARE:
     {
-        CFixedVector2D halfSize(goal.hw, goal.hh);
-        CFixedVector2D d = pos - g;
+        const CFixedVector2D halfSize(goal.hw, goal.hh);
+        const CFixedVector2D d(pos - g);
         return g + Geometry::NearestPointOnSquare(d, goal.u, goal.v, halfSize);
     }
 
@@ -317 +301 @@
     }
 }
 
-CFixedVector2D CCmpPathfinder::GetNearestPointOnGoal(CFixedVector2D pos, const CCmpPathfinder::Goal& goal)
+CFixedVector2D CCmpPathfinder::GetNearestPointOnGoal(const CFixedVector2D& pos, const CCmpPathfinder::Goal& goal) const
 {
     return NearestPointOnGoal(pos, goal);
     // (It's intentional that we don't put the implementation inside this
@@ -333 +317 @@
     enum { TOP, BOTTOM, LEFT, RIGHT } dir;
 };
 
-static void AddTerrainEdges(std::vector<Edge>& edgesAA, std::vector<Vertex>& vertexes,
-    u16 i0, u16 j0, u16 i1, u16 j1, fixed r,
-    ICmpPathfinder::pass_class_t passClass, const Grid<TerrainTile>& terrain)
+std::vector<TileEdge> tileEdges;
+
+static void AddTerrainEdges(std::vector<Edge>& edgesAA, std::vector<Vertex>& vertices,
+    const u16 i0, const u16 j0, const u16 i1, const u16 j1, const fixed r,
+    const ICmpPathfinder::pass_class_t passClass, const Grid<TerrainTile>& terrain)
 {
     PROFILE("AddTerrainEdges");
 
-    std::vector<TileEdge> tileEdges;
+    tileEdges.clear();
+    // Find all edges between tiles of differently passability statuses
 
-    // Find all edges between tiles of differently passability statuses
+    bool any;
+    const u16 terrainW = terrain.m_W;
+    const u16 terrainmWOne = terrainW-1;
+    const u16 terrainmHOne = terrain.m_H-1;
+    const TerrainTile * const __restrict  data = terrain.m_Data;
     for (u16 j = j0; j <= j1; ++j)
     {
+        const bool jInsideUp = j < terrainmHOne;
+        const bool jInsideDown = j != 0;
+        const u32 jPos = j*terrainW;
         for (u16 i = i0; i <= i1; ++i)
         {
-            if (!IS_TERRAIN_PASSABLE(terrain.get(i, j), passClass))
+            if (!IS_TERRAIN_PASSABLE(data[i+jPos], passClass))
             {
-                bool any = false; // whether we're adding any edges of this tile
+                any = false; // whether we're adding any edges of this tile
 
-                if (j > 0 && IS_TERRAIN_PASSABLE(terrain.get(i, j-1), passClass))
+                if (jInsideDown && IS_TERRAIN_PASSABLE(data[i+jPos-terrainW], passClass))
                 {
-                    TileEdge e = { i, j, TileEdge::BOTTOM };
+                    const TileEdge e = { i, j, TileEdge::BOTTOM };
                     tileEdges.push_back(e);
                     any = true;
                 }
 
-                if (j < terrain.m_H-1 && IS_TERRAIN_PASSABLE(terrain.get(i, j+1), passClass))
+                if (jInsideUp && IS_TERRAIN_PASSABLE(data[i+jPos+terrainW], passClass))
                 {
-                    TileEdge e = { i, j, TileEdge::TOP };
+                    const TileEdge e = { i, j, TileEdge::TOP };
                     tileEdges.push_back(e);
                     any = true;
                 }
 
-                if (i > 0 && IS_TERRAIN_PASSABLE(terrain.get(i-1, j), passClass))
+                if (i != 0 && IS_TERRAIN_PASSABLE(data[i+jPos-1], passClass))
                 {
-                    TileEdge e = { i, j, TileEdge::LEFT };
+                    const TileEdge e = { i, j, TileEdge::LEFT };
                     tileEdges.push_back(e);
                     any = true;
                 }
 
-                if (i < terrain.m_W-1 && IS_TERRAIN_PASSABLE(terrain.get(i+1, j), passClass))
+                if (i < terrainmWOne && IS_TERRAIN_PASSABLE(data[i+jPos+1], passClass))
                 {
-                    TileEdge e = { i, j, TileEdge::RIGHT };
+                    const TileEdge e = { i, j, TileEdge::RIGHT };
                     tileEdges.push_back(e);
                     any = true;
                 }
@@ -382 +376 @@
                 // (The inner edges are redundant but it's easier than trying to split the squares apart.)
                 if (any)
                 {
-                    CFixedVector2D v0 = CFixedVector2D(fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
-                    CFixedVector2D v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
-                    Edge e = { v0, v1 };
+                    const CFixedVector2D v0 (fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
+                    const CFixedVector2D v1 (fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
+                    const Edge e = { v0, v1 };
                     edgesAA.push_back(e);
                 }
             }
@@ -396 +390 @@
     // TODO: for efficiency (minimising the A* search space), we should coalesce adjoining edges
 
     // Add all the tile outer edges to the search vertex lists
-    for (size_t n = 0; n < tileEdges.size(); ++n)
-    {
-        u16 i = tileEdges[n].i;
-        u16 j = tileEdges[n].j;
-        CFixedVector2D v0, v1;
-        Vertex vert;
-        vert.status = Vertex::UNEXPLORED;
-        vert.quadOutward = QUADRANT_ALL;
 
-        switch (tileEdges[n].dir)
+    Vertex vert;
+    vert.status = Vertex::UNEXPLORED;
+    vert.quadOutward = QUADRANT_ALL;
+    const std::vector<TileEdge>::const_iterator itEnd = tileEdges.end();
+    for (std::vector<TileEdge>::const_iterator it = tileEdges.begin(); it != itEnd; ++it)
+    {       
+        const TileEdge& tileEdge = *it;
+        const u16 i = tileEdge.i;
+        const u16 j = tileEdge.j;
+
+        switch (tileEdge.dir)
         {
         case TileEdge::BOTTOM:
         {
-            v0 = CFixedVector2D(fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
-            v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
-            vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
-            vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
+            const CFixedVector2D v0 (fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
+            const CFixedVector2D v1 (fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
+            vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertices.push_back(vert);
+            vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertices.push_back(vert);
             break;
         }
         case TileEdge::TOP:
         {
-            v0 = CFixedVector2D(fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
-            v1 = CFixedVector2D(fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
-            vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
-            vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
+            const CFixedVector2D v0 (fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
+            const CFixedVector2D v1 (fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
+            vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertices.push_back(vert);
+            vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertices.push_back(vert);
             break;
         }
         case TileEdge::LEFT:
         {
-            v0 = CFixedVector2D(fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
-            v1 = CFixedVector2D(fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
-            vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
-            vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
+            const CFixedVector2D v0 (fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
+            const CFixedVector2D v1 (fixed::FromInt(i * (int)TERRAIN_TILE_SIZE) - r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
+            vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertices.push_back(vert);
+            vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertices.push_back(vert);
             break;
         }
         case TileEdge::RIGHT:
         {
-            v0 = CFixedVector2D(fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
-            v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
-            vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
-            vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
+            const CFixedVector2D v0 (fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt(j * (int)TERRAIN_TILE_SIZE) - r);
+            const CFixedVector2D v1 (fixed::FromInt((i+1) * (int)TERRAIN_TILE_SIZE) + r, fixed::FromInt((j+1) * (int)TERRAIN_TILE_SIZE) + r);
+            vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertices.push_back(vert);
+            vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertices.push_back(vert);
             break;
         }
         }
@@ -448 +444 @@
         std::vector<EdgeAA>& edgesLeft, std::vector<EdgeAA>& edgesRight,
         std::vector<EdgeAA>& edgesBottom, std::vector<EdgeAA>& edgesTop)
 {
-    edgesLeft.reserve(edgesAA.size());
-    edgesRight.reserve(edgesAA.size());
-    edgesBottom.reserve(edgesAA.size());
-    edgesTop.reserve(edgesAA.size());
+    const size_t edgeSize = edgesAA.size();
+    edgesLeft.reserve(edgeSize);
+    edgesRight.reserve(edgeSize);
+    edgesBottom.reserve(edgeSize);
+    edgesTop.reserve(edgeSize);
 
-    for (size_t i = 0; i < edgesAA.size(); ++i)
+    const std::vector<Edge>::const_iterator itEnd = edgesAA.end();
+    for (std::vector<Edge>::const_iterator it = edgesAA.begin(); it != itEnd; ++it)
     {
-        if (a.X <= edgesAA[i].p0.X)
+        const Edge& edge = *it;
+        if (a.X <= edge.p0.X)
         {
-            EdgeAA e = { edgesAA[i].p0, edgesAA[i].p1.Y };
+            EdgeAA e = { edge.p0, edge.p1.Y };
             edgesLeft.push_back(e);
         }
-        if (a.X >= edgesAA[i].p1.X)
+        if (a.X >= edge.p1.X)
         {
-            EdgeAA e = { edgesAA[i].p1, edgesAA[i].p0.Y };
+            EdgeAA e = { edge.p1, edge.p0.Y };
             edgesRight.push_back(e);
         }
-        if (a.Y <= edgesAA[i].p0.Y)
+        if (a.Y <= edge.p0.Y)
         {
-            EdgeAA e = { edgesAA[i].p0, edgesAA[i].p1.X };
+            EdgeAA e = { edge.p0, edge.p1.X };
             edgesBottom.push_back(e);
         }
-        if (a.Y >= edgesAA[i].p1.Y)
+        if (a.Y >= edge.p1.Y)
         {
-            EdgeAA e = { edgesAA[i].p1, edgesAA[i].p0.X };
+            EdgeAA e = { edge.p1, edge.p0.X };
             edgesTop.push_back(e);
         }
     }
@@ -485 +484 @@
 {
     CFixedVector2D src;
     EdgeSort(CFixedVector2D src) : src(src) { }
-    bool operator()(const Edge& a, const Edge& b)
+    bool operator()(const Edge& a, const Edge& b) const
     {
         if ((a.p0 - src).CompareLength(b.p0 - src) < 0)
             return true;
@@ -493 +492 @@
     }
 };
 
+// List of collision edges - paths must never cross these.
+// (Edges are one-sided so intersections are fine in one direction, but not the other direction.)
+std::vector<Edge> edges;
+std::vector<Edge> edgesAA; // axis-aligned squares
+// List of obstruction vertices (plus start/end points); we'll try to find paths through
+// the graph defined by these vertices
+std::vector<Vertex> vertices;
+std::vector<ICmpObstructionManager::ObstructionSquare> squares;
+
+std::vector<EdgeAA> edgesLeft;
+std::vector<EdgeAA> edgesRight;
+std::vector<EdgeAA> edgesBottom;
+std::vector<EdgeAA> edgesTop;
+
 void CCmpPathfinder::ComputeShortPath(const IObstructionTestFilter& filter,
     entity_pos_t x0, entity_pos_t z0, entity_pos_t r,
     entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& path)
@@ -530 +543 @@
         }
     }
 
-    // List of collision edges - paths must never cross these.
-    // (Edges are one-sided so intersections are fine in one direction, but not the other direction.)
-    std::vector<Edge> edges;
-    std::vector<Edge> edgesAA; // axis-aligned squares
 
+    edges.clear();
+    edgesAA.clear();
+    vertices.clear();
+    squares.clear();
+
     // Create impassable edges at the max-range boundary, so we can't escape the region
     // where we're meant to be searching
-    fixed rangeXMin = x0 - range;
-    fixed rangeXMax = x0 + range;
-    fixed rangeZMin = z0 - range;
-    fixed rangeZMax = z0 + range;
+    const fixed rangeXMin = x0 - range;
+    const fixed rangeXMax = x0 + range;
+    const fixed rangeZMin = z0 - range;
+    const fixed rangeZMax = z0 + range;
     {
         // (The edges are the opposite direction to usual, so it's an inside-out square)
         Edge e0 = { CFixedVector2D(rangeXMin, rangeZMin), CFixedVector2D(rangeXMin, rangeZMax) };
@@ -553 +567 @@
         edges.push_back(e3);
     }
 
-    // List of obstruction vertexes (plus start/end points); we'll try to find paths through
-    // the graph defined by these vertexes
-    std::vector<Vertex> vertexes;
 
     // Add the start point to the graph
-    CFixedVector2D posStart(x0, z0);
-    fixed hStart = (posStart - NearestPointOnGoal(posStart, goal)).Length();
-    Vertex start = { posStart, fixed::Zero(), hStart, 0, Vertex::OPEN, QUADRANT_NONE, QUADRANT_ALL };
-    vertexes.push_back(start);
+    const CFixedVector2D posStart(x0, z0);
+    const fixed hStart = (posStart - NearestPointOnGoal(posStart, goal)).Length();
+    const Vertex start = { posStart, fixed::Zero(), hStart, 0, Vertex::OPEN, QUADRANT_NONE, QUADRANT_ALL };
+    vertices.push_back(start);
+
     const size_t START_VERTEX_ID = 0;
 
     // Add the goal vertex to the graph.
     // Since the goal isn't always a point, this a special magic virtual vertex which moves around - whenever
     // we look at it from another vertex, it is moved to be the closest point on the goal shape to that vertex.
-    Vertex end = { CFixedVector2D(goal.x, goal.z), fixed::Zero(), fixed::Zero(), 0, Vertex::UNEXPLORED, QUADRANT_NONE, QUADRANT_ALL };
-    vertexes.push_back(end);
+    {
+        const Vertex end = { CFixedVector2D(goal.x, goal.z), fixed::Zero(), fixed::Zero(), 0, Vertex::UNEXPLORED, QUADRANT_NONE, QUADRANT_ALL };
+        vertices.push_back(end);
+    }
     const size_t GOAL_VERTEX_ID = 1;
 
     // Add terrain obstructions
@@ -576 +590 @@
         u16 i0, j0, i1, j1;
         NearestTile(rangeXMin, rangeZMin, i0, j0);
         NearestTile(rangeXMax, rangeZMax, i1, j1);
-        AddTerrainEdges(edgesAA, vertexes, i0, j0, i1, j1, r, passClass, *m_Grid);
+        AddTerrainEdges(edgesAA, vertices, i0, j0, i1, j1, r, passClass, *m_Grid);
     }
 
     // Find all the obstruction squares that might affect us
     CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
-    std::vector<ICmpObstructionManager::ObstructionSquare> squares;
     cmpObstructionManager->GetObstructionsInRange(filter, rangeXMin - r, rangeZMin - r, rangeXMax + r, rangeZMax + r, squares);
 
     // Resize arrays to reduce reallocations
-    vertexes.reserve(vertexes.size() + squares.size()*4);
+    vertices.reserve(vertices.size() + squares.size()*4);
     edgesAA.reserve(edgesAA.size() + squares.size()); // (assume most squares are AA)
 
-    // Convert each obstruction square into collision edges and search graph vertexes
-    for (size_t i = 0; i < squares.size(); ++i)
+    // Convert each obstruction square into collision edges and search graph vertices
+    
+    Vertex vert;
+    const std::vector<ICmpObstructionManager::ObstructionSquare>::const_iterator itEnd = squares.end();
+    for (std::vector<ICmpObstructionManager::ObstructionSquare>::const_iterator it = squares.begin(); it != itEnd; ++it)
     {
-        CFixedVector2D center(squares[i].x, squares[i].z);
-        CFixedVector2D u = squares[i].u;
-        CFixedVector2D v = squares[i].v;
+        const ICmpObstructionManager::ObstructionSquare& square = *it;
 
-        // Expand the vertexes by the moving unit's collision radius, to find the
+        const CFixedVector2D center(square.x, square.z);
+        const CFixedVector2D& u = square.u;
+        const CFixedVector2D& v = square.v;
+
+        // Expand the vertices by the moving unit's collision radius, to find the
         // closest we can get to it
 
-        CFixedVector2D hd0(squares[i].hw + r + EDGE_EXPAND_DELTA, squares[i].hh + r + EDGE_EXPAND_DELTA);
-        CFixedVector2D hd1(squares[i].hw + r + EDGE_EXPAND_DELTA, -(squares[i].hh + r + EDGE_EXPAND_DELTA));
+        const CFixedVector2D hd0(square.hw + r + EDGE_EXPAND_DELTA, square.hh + r + EDGE_EXPAND_DELTA);
+        const CFixedVector2D hd1(square.hw + r + EDGE_EXPAND_DELTA, -(square.hh + r + EDGE_EXPAND_DELTA));
 
         // Check whether this is an axis-aligned square
-        bool aa = (u.X == fixed::FromInt(1) && u.Y == fixed::Zero() && v.X == fixed::Zero() && v.Y == fixed::FromInt(1));
+        const bool aa = (u.X == fixed::FromInt(1) && u.Y == fixed::Zero() && v.X == fixed::Zero() && v.Y == fixed::FromInt(1));
 
-        Vertex vert;
         vert.status = Vertex::UNEXPLORED;
         vert.quadInward = QUADRANT_NONE;
         vert.quadOutward = QUADRANT_ALL;
-        vert.p.X = center.X - hd0.Dot(u); vert.p.Y = center.Y + hd0.Dot(v); if (aa) vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
-        vert.p.X = center.X - hd1.Dot(u); vert.p.Y = center.Y + hd1.Dot(v); if (aa) vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
-        vert.p.X = center.X + hd0.Dot(u); vert.p.Y = center.Y - hd0.Dot(v); if (aa) vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
-        vert.p.X = center.X + hd1.Dot(u); vert.p.Y = center.Y - hd1.Dot(v); if (aa) vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
+        vert.p.X = center.X - hd0.Dot(u); vert.p.Y = center.Y + hd0.Dot(v); if (aa) vert.quadInward = QUADRANT_BR; vertices.push_back(vert);
+        vert.p.X = center.X - hd1.Dot(u); vert.p.Y = center.Y + hd1.Dot(v); if (aa) vert.quadInward = QUADRANT_TR; vertices.push_back(vert);
+        vert.p.X = center.X + hd0.Dot(u); vert.p.Y = center.Y - hd0.Dot(v); if (aa) vert.quadInward = QUADRANT_TL; vertices.push_back(vert);
+        vert.p.X = center.X + hd1.Dot(u); vert.p.Y = center.Y - hd1.Dot(v); if (aa) vert.quadInward = QUADRANT_BL; vertices.push_back(vert);
 
         // Add the edges:
 
-        CFixedVector2D h0(squares[i].hw + r, squares[i].hh + r);
-        CFixedVector2D h1(squares[i].hw + r, -(squares[i].hh + r));
+        const CFixedVector2D h1(square.hw + r, -(square.hh + r));
+        
+        const fixed h1DotU(h1.Dot(u));
+        const fixed h1DotV(h1.Dot(v));
 
-        CFixedVector2D ev0(center.X - h0.Dot(u), center.Y + h0.Dot(v));
-        CFixedVector2D ev1(center.X - h1.Dot(u), center.Y + h1.Dot(v));
-        CFixedVector2D ev2(center.X + h0.Dot(u), center.Y - h0.Dot(v));
-        CFixedVector2D ev3(center.X + h1.Dot(u), center.Y - h1.Dot(v));
+        const CFixedVector2D ev1(center.X - h1DotU, center.Y + h1DotV);
+        const CFixedVector2D ev3(center.X + h1DotU, center.Y - h1DotV);
         if (aa)
         {
             Edge e = { ev1, ev3 };
@@ -629 +646 @@
         }
         else
         {
+            const CFixedVector2D h0(square.hw + r, square.hh + r);
+
+            const fixed h0DotU(h0.Dot(u));
+            const fixed h0DotV(h0.Dot(v));
+
+            const CFixedVector2D ev0(center.X - h0DotU, center.Y + h0DotV);
+            const CFixedVector2D ev2(center.X + h0DotU, center.Y - h0DotV);
+
             Edge e0 = { ev0, ev1 };
             Edge e1 = { ev1, ev2 };
             Edge e2 = { ev2, ev3 };
             Edge e3 = { ev3, ev0 };
+
             edges.push_back(e0);
             edges.push_back(e1);
             edges.push_back(e2);
             edges.push_back(e3);
         }
 
-        // TODO: should clip out vertexes and edges that are outside the range,
+        // TODO: should clip out vertices and edges that are outside the range,
         // to reduce the search space
     }
 
-    ENSURE(vertexes.size() < 65536); // we store array indexes as u16
+    ENSURE(vertices.size() < 65536); // we store array indexes as u16
 
     if (m_DebugOverlay)
     {
@@ -684 +710 @@
     // Since we are just measuring Euclidean distance the heuristic is admissible,
     // so we never have to re-examine a node once it's been moved to the closed set.
 
-    // To save time in common cases, we don't precompute a graph of valid edges between vertexes;
+    // To save time in common cases, we don't precompute a graph of valid edges between vertices;
     // we do it lazily instead. When the search algorithm reaches a vertex, we examine every other
     // vertex and see if we can reach it without hitting any collision edges, and ignore the ones
     // we can't reach. Since the algorithm can only reach a vertex once (and then it'll be marked
@@ -703 +729 @@
     {
         // Move best tile from open to closed
         PriorityQueue::Item curr = open.pop();
-        vertexes[curr.id].status = Vertex::CLOSED;
+        vertices[curr.id].status = Vertex::CLOSED;
 
         // If we've reached the destination, stop
         if (curr.id == GOAL_VERTEX_ID)
@@ -712 +738 @@
             break;
         }
 
+        const Vertex &VertexCurr = vertices[curr.id];
+        const CFixedVector2D& vertexPosition = VertexCurr.p;
+        
         // Sort the edges so ones nearer this vertex are checked first by CheckVisibility,
         // since they're more likely to block the rays
-        std::sort(edgesAA.begin(), edgesAA.end(), EdgeSort(vertexes[curr.id].p));
+        std::sort(edgesAA.begin(), edgesAA.end(), EdgeSort(VertexCurr.p));
 
-        std::vector<EdgeAA> edgesLeft;
-        std::vector<EdgeAA> edgesRight;
-        std::vector<EdgeAA> edgesBottom;
-        std::vector<EdgeAA> edgesTop;
-        SplitAAEdges(vertexes[curr.id].p, edgesAA, edgesLeft, edgesRight, edgesBottom, edgesTop);
+        edgesLeft.clear();
+        edgesRight.clear();
+        edgesBottom.clear();
+        edgesTop.clear();
+        SplitAAEdges(VertexCurr.p, edgesAA, edgesLeft, edgesRight, edgesBottom, edgesTop);
 
         // Check the lines to every other vertex
-        for (size_t n = 0; n < vertexes.size(); ++n)
+        size_t n = 0;
+        const std::vector<Vertex>::iterator itVEnd = vertices.end();
+        for (std::vector<Vertex>::iterator itv = vertices.begin(); itv != itVEnd; ++itv, n++)
         {
-            if (vertexes[n].status == Vertex::CLOSED)
+            Vertex& vertexN = *itv;
+            if (vertexN.status == Vertex::CLOSED)
                 continue;
 
             // If this is the magical goal vertex, move it to near the current vertex
             CFixedVector2D npos;
             if (n == GOAL_VERTEX_ID)
             {
-                npos = NearestPointOnGoal(vertexes[curr.id].p, goal);
+                npos = NearestPointOnGoal(vertexPosition, goal);
 
-                // To prevent integer overflows later on, we need to ensure all vertexes are
+                // To prevent integer overflows later on, we need to ensure all vertices are
                 // 'close' to the source. The goal might be far away (not a good idea but
                 // sometimes it happens), so clamp it to the current search range
                 npos.X = clamp(npos.X, rangeXMin, rangeXMax);
@@ -742 +774 @@
             }
             else
             {
-                npos = vertexes[n].p;
+                npos = vertexN.p;
             }
 
             // Work out which quadrant(s) we're approaching the new vertex from
-            u8 quad = 0;
-            if (vertexes[curr.id].p.X <= npos.X && vertexes[curr.id].p.Y <= npos.Y) quad |= QUADRANT_BL;
-            if (vertexes[curr.id].p.X >= npos.X && vertexes[curr.id].p.Y >= npos.Y) quad |= QUADRANT_TR;
-            if (vertexes[curr.id].p.X <= npos.X && vertexes[curr.id].p.Y >= npos.Y) quad |= QUADRANT_TL;
-            if (vertexes[curr.id].p.X >= npos.X && vertexes[curr.id].p.Y <= npos.Y) quad |= QUADRANT_BR;
+            u8 quad = 0;    
 
+            if (vertexPosition.X <= npos.X && vertexPosition.Y <= npos.Y) quad |= QUADRANT_BL;
+            if (vertexPosition.X >= npos.X && vertexPosition.Y >= npos.Y) quad |= QUADRANT_TR;
+            if (vertexPosition.X <= npos.X && vertexPosition.Y >= npos.Y) quad |= QUADRANT_TL;
+            if (vertexPosition.X >= npos.X && vertexPosition.Y <= npos.Y) quad |= QUADRANT_BR;
+
             // Check that the new vertex is in the right quadrant for the old vertex
-            if (!(vertexes[curr.id].quadOutward & quad))
+            if (!(VertexCurr.quadOutward & quad))
             {
                 // Hack: Always head towards the goal if possible, to avoid missing it if it's
                 // inside another unit
@@ -763 +796 @@
                 }
             }
 
-            bool visible =
-                CheckVisibilityLeft(vertexes[curr.id].p, npos, edgesLeft) &&
-                CheckVisibilityRight(vertexes[curr.id].p, npos, edgesRight) &&
-                CheckVisibilityBottom(vertexes[curr.id].p, npos, edgesBottom) &&
-                CheckVisibilityTop(vertexes[curr.id].p, npos, edgesTop) &&
-                CheckVisibility(vertexes[curr.id].p, npos, edges);
+            const CFixedVector2D abn ((npos - vertexPosition).Perpendicular());
+            bool visible = CheckVisibilityLeft(vertexPosition, npos, abn, edgesLeft) &&
+                CheckVisibilityRight(vertexPosition, npos, abn,  edgesRight) &&
+                CheckVisibilityBottom(vertexPosition, npos, abn,  edgesBottom) &&
+                CheckVisibilityTop(vertexPosition, npos, abn,  edgesTop) && 
+                CheckVisibility(vertexPosition, npos, abn,  edges);
+            
+            
 
             /*
             // Render the edges that we examine
             m_DebugOverlayShortPathLines.push_back(SOverlayLine());
             m_DebugOverlayShortPathLines.back().m_Color = visible ? CColor(0, 1, 0, 0.5) : CColor(1, 0, 0, 0.5);
             std::vector<float> xz;
-            xz.push_back(vertexes[curr.id].p.X.ToFloat());
-            xz.push_back(vertexes[curr.id].p.Y.ToFloat());
+            xz.push_back(VertexCurr.p.X.ToFloat());
+            xz.push_back(VertexCurr.p.Y.ToFloat());
             xz.push_back(npos.X.ToFloat());
             xz.push_back(npos.Y.ToFloat());
             SimRender::ConstructLineOnGround(GetSimContext(), xz, m_DebugOverlayShortPathLines.back(), false);
@@ -784 +819 @@
 
             if (visible)
             {
-                fixed g = vertexes[curr.id].g + (vertexes[curr.id].p - npos).Length();
+                const fixed g = VertexCurr.g + (vertexPosition - npos).Length();
 
                 // If this is a new tile, compute the heuristic distance
-                if (vertexes[n].status == Vertex::UNEXPLORED)
+                if (vertexN.status == Vertex::UNEXPLORED)
                 {
                     // Add it to the open list:
-                    vertexes[n].status = Vertex::OPEN;
-                    vertexes[n].g = g;
-                    vertexes[n].h = DistanceToGoal(npos, goal);
-                    vertexes[n].pred = curr.id;
+                    vertexN.status = Vertex::OPEN;
+                    vertexN.g = g;
+                    vertexN.h = DistanceToGoal(npos, goal);
+                    vertexN.pred = curr.id;
 
                     // If this is an axis-aligned shape, the path must continue in the same quadrant
                     // direction (but not go into the inside of the shape).
                     // Hack: If we started *inside* a shape then perhaps headed to its corner (e.g. the unit
                     // was very near another unit), don't restrict further pathing.
-                    if (vertexes[n].quadInward && !(curr.id == START_VERTEX_ID && g < fixed::FromInt(8)))
-                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad) & 0xF;
+                    if (vertexN.quadInward && !(curr.id == START_VERTEX_ID && g < fixed::FromInt(8)))
+                        vertexN.quadOutward = ((~vertexN.quadInward) & quad) & 0xF;
 
                     if (n == GOAL_VERTEX_ID)
-                        vertexes[n].p = npos; // remember the new best goal position
+                        vertexN.p = npos; // remember the new best goal position
 
-                    PriorityQueue::Item t = { (u16)n, g + vertexes[n].h };
+                    PriorityQueue::Item t = { (u16)n, g + vertexN.h };
                     open.push(t);
 
                     // Remember the heuristically best vertex we've seen so far, in case we never actually reach the target
-                    if (vertexes[n].h < hBest)
+                    if (vertexN.h < hBest)
                     {
                         idBest = (u16)n;
-                        hBest = vertexes[n].h;
+                        hBest = vertexN.h;
                     }
                 }
                 else // must be OPEN
                 {
                     // If we've already seen this tile, and the new path to this tile does not have a
                     // better cost, then stop now
-                    if (g >= vertexes[n].g)
+                    if (g >= vertexN.g)
                         continue;
 
                     // Otherwise, we have a better path, so replace the old one with the new cost/parent
-                    vertexes[n].g = g;
-                    vertexes[n].pred = curr.id;
+                    vertexN.g = g;
+                    vertexN.pred = curr.id;
 
                     // If this is an axis-aligned shape, the path must continue in the same quadrant
                     // direction (but not go into the inside of the shape).
-                    if (vertexes[n].quadInward)
-                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad) & 0xF;
+                    if (vertexN.quadInward)
+                        vertexN.quadOutward = ((~vertexN.quadInward) & quad) & 0xF;
 
                     if (n == GOAL_VERTEX_ID)
-                        vertexes[n].p = npos; // remember the new best goal position
+                        vertexN.p = npos; // remember the new best goal position
 
-                    open.promote((u16)n, g + vertexes[n].h);
+                    open.promote((u16)n, g + vertexN.h);
                 }
             }
         }
     }
 
     // Reconstruct the path (in reverse)
-    for (u16 id = idBest; id != START_VERTEX_ID; id = vertexes[id].pred)
+    for (u16 id = idBest; id != START_VERTEX_ID; id = vertices[id].pred)
     {
-        Waypoint w = { vertexes[id].p.X, vertexes[id].p.Y };
+        Waypoint w = { vertices[id].p.X, vertices[id].p.Y };
         path.m_Waypoints.push_back(w);
     }
 
@@ -867 +902 @@
 
     UpdateGrid();
 
-    std::vector<Edge> edgesAA;
-    std::vector<Vertex> vertexes;
+    edgesAA.clear();
+    vertices.clear();
 
     u16 i0, j0, i1, j1;
     NearestTile(std::min(x0, x1) - r, std::min(z0, z1) - r, i0, j0);
     NearestTile(std::max(x0, x1) + r, std::max(z0, z1) + r, i1, j1);
-    AddTerrainEdges(edgesAA, vertexes, i0, j0, i1, j1, r, passClass, *m_Grid);
+    AddTerrainEdges(edgesAA, vertices, i0, j0, i1, j1, r, passClass, *m_Grid);
 
     CFixedVector2D a(x0, z0);
     CFixedVector2D b(x1, z1);
 
-    std::vector<EdgeAA> edgesLeft;
-    std::vector<EdgeAA> edgesRight;
-    std::vector<EdgeAA> edgesBottom;
-    std::vector<EdgeAA> edgesTop;
+    edgesLeft.clear();
+    edgesRight.clear();
+    edgesBottom.clear();
+    edgesTop.clear();
     SplitAAEdges(a, edgesAA, edgesLeft, edgesRight, edgesBottom, edgesTop);
 
+
+    const CFixedVector2D abn ((b - a).Perpendicular());
     bool visible =
-        CheckVisibilityLeft(a, b, edgesLeft) &&
-        CheckVisibilityRight(a, b, edgesRight) &&
-        CheckVisibilityBottom(a, b, edgesBottom) &&
-        CheckVisibilityTop(a, b, edgesTop);
+        CheckVisibilityLeft(a, b, abn, edgesLeft) &&
+        CheckVisibilityRight(a, b, abn,  edgesRight) &&
+        CheckVisibilityBottom(a, b, abn, edgesBottom) &&
+        CheckVisibilityTop(a, b, abn,  edgesTop);
 
+
+
+
+
     return visible;
 }

source/simulation2/components/CCmpPathfinder.cpp

@@ -238 +238 @@
 }
 
 
-fixed CCmpPathfinder::GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, u8 costClass)
+fixed CCmpPathfinder::GetMovementSpeed(const entity_pos_t x0, const entity_pos_t z0, u8 costClass) 
 {
     UpdateGrid();
 
@@ -275 +275 @@
     return m_UnitCostClassTags[name];
 }
 
-fixed CCmpPathfinder::DistanceToGoal(CFixedVector2D pos, const CCmpPathfinder::Goal& goal)
+fixed CCmpPathfinder::DistanceToGoal( const CFixedVector2D& pos, const CCmpPathfinder::Goal& goal) 
 {
     switch (goal.type)
     {

source/simulation2/components/CCmpPathfinder_Tile.cpp

@@ -20 +20 @@
  * Tile-based algorithm for CCmpPathfinder.
  * This is a fairly naive algorithm and could probably be improved substantially
  * (hopefully without needing to change the interface much).
+ * TODO: 
+ ** use squared length for all distance comparisons, saves a sqrt per comparison: huge speed up
+ ** use pointers for edge so that memory movement are smaller, prealloc edge using memory pools so that data is contiguous: huge speed up
  */
 
 #include "precompiled.h"
@@ -53 +56 @@
         STATUS_CLOSED = 2
     };
 
-    bool IsUnexplored() { return status == STATUS_UNEXPLORED; }
-    bool IsOpen() { return status == STATUS_OPEN; }
-    bool IsClosed() { return status == STATUS_CLOSED; }
+    bool IsUnexplored() const{ return status == STATUS_UNEXPLORED; }
+    bool IsOpen()const { return status == STATUS_OPEN; }
+    bool IsClosed()const { return status == STATUS_CLOSED; }
     void SetStatusOpen() { status = STATUS_OPEN; }
     void SetStatusClosed() { status = STATUS_CLOSED; }
 
     // Get pi,pj coords of predecessor to this tile on best path, given i,j coords of this tile
-    u16 GetPredI(u16 i) { return (u16)(i + dpi); }
-    u16 GetPredJ(u16 j) { return (u16)(j + dpj); }
+    u16 GetPredI(const u16 i) const { return (u16)(i + dpi); }
+    u16 GetPredJ(const u16 j) const { return (u16)(j + dpj); }
     // Set the pi,pj coords of predecessor, given i,j coords of this tile
     void SetPred(u16 pi_, u16 pj_, u16 i, u16 j)
     {
@@ -82 +85 @@
     u32 h; // h (heuristic cost to goal) (TODO: is it really better for performance to store this instead of recomputing?)
 
 #if PATHFIND_DEBUG
-    u32 GetStep() { return step; }
-    void SetStep(u32 s) { step = s; }
+    u32 GetStep() const{ return step; }
+    void SetStep(const u32 s) { step = s; }
 private:
     u32 step; // step at which this tile was last processed (for debug rendering)
 #else
-    u32 GetStep() { return 0; }
-    void SetStep(u32) { }
+    u32 GetStep()const { return 0; }
+    void SetStep(const u32) { }
 #endif
 
 };
@@ -113 +116 @@
         m_Pathfinder.UpdateGrid();
     }
 
-    virtual void ProcessTile(ssize_t i, ssize_t j)
+    virtual void ProcessTile(const ssize_t i, const ssize_t j)
     {
         if (m_Pathfinder.m_Grid && !IS_PASSABLE(m_Pathfinder.m_Grid->get((int)i, (int)j), m_Pathfinder.m_DebugPassClass))
             RenderTile(CColor(1, 0, 0, 0.6f), false);
@@ -215 +218 @@
 #endif
 };
 
-static bool AtGoal(u16 i, u16 j, const ICmpPathfinder::Goal& goal)
+static bool AtGoal(const u16 i, const u16 j, const ICmpPathfinder::Goal& goal)
 {
     // Allow tiles slightly more than sqrt(2) from the actual goal,
     // i.e. adjacent diagonally to the target tile
-    fixed tolerance = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*3/2);
+    const fixed tolerance = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*3/2);
 
     entity_pos_t x, z;
     CCmpPathfinder::TileCenter(i, j, x, z);
-    fixed dist = CCmpPathfinder::DistanceToGoal(CFixedVector2D(x, z), goal);
+    const fixed dist = CCmpPathfinder::DistanceToGoal(CFixedVector2D(x, z), goal);
     return (dist < tolerance);
 }
 
 // Calculate heuristic cost from tile i,j to destination
 // (This ought to be an underestimate for correctness)
-static u32 CalculateHeuristic(u16 i, u16 j, u16 iGoal, u16 jGoal, u16 rGoal)
+static u32 CalculateHeuristic(const u16 i, const u16 j, const u16 iGoal, const u16 jGoal, const u16 rGoal)
 {
 #if USE_DIAGONAL_MOVEMENT
-    CFixedVector2D pos (fixed::FromInt(i), fixed::FromInt(j));
-    CFixedVector2D goal (fixed::FromInt(iGoal), fixed::FromInt(jGoal));
-    fixed dist = (pos - goal).Length();
+    const CFixedVector2D pos (fixed::FromInt(i), fixed::FromInt(j));
+    const CFixedVector2D goal (fixed::FromInt(iGoal), fixed::FromInt(jGoal));
+    const fixed dist = pos.computeDistanceLength(goal);
     // TODO: the heuristic could match the costs better - it's not really Euclidean movement
 
     fixed rdist = dist - fixed::FromInt(rGoal);
@@ -255 +258 @@
 }
 
 // Calculate movement cost from predecessor tile pi,pj to tile i,j
-static u32 CalculateCostDelta(u16 pi, u16 pj, u16 i, u16 j, PathfindTileGrid* tempGrid, u32 tileCost)
+static u32 CalculateCostDelta(const u16 pi, const u16 pj, const PathfindTile &p, 
+                                const u16 i, const u16 j, 
+                                PathfindTileGrid* const tempGrid, 
+                                const u32 tileCost)
 {
     u32 dg = tileCost;
 
@@ -269 +275 @@
     // likely to be reasonably stable) and reducing the cost, and use a Euclidean heuristic.
     // At least this makes paths look a bit nicer for now...
 
-    PathfindTile& p = tempGrid->get(pi, pj);
-    u16 ppi = p.GetPredI(pi);
-    u16 ppj = p.GetPredJ(pj);
+    //PathfindTile& p = tempGrid->get(pi, pj);
+    const u16 ppi = p.GetPredI(pi);
+    const u16 ppj = p.GetPredJ(pj);
     if (ppi != i && ppj != j)
+    {
         dg = (dg << 16) / 92682; // dg*sqrt(2)/2
+    }
     else
     {
-        PathfindTile& pp = tempGrid->get(ppi, ppj);
-        int di = abs(i - pp.GetPredI(ppi));
-        int dj = abs(j - pp.GetPredJ(ppj));
+        const PathfindTile& pp = tempGrid->get(ppi, ppj);
+        const int di = abs(i - pp.GetPredI(ppi));
+        const int dj = abs(j - pp.GetPredJ(ppj));
         if ((di == 1 && dj == 2) || (di == 2 && dj == 1))
             dg = (dg << 16) / 79742; // dg*(sqrt(5)-sqrt(2))
     }
@@ -288 +296 @@
 }
 
 // Do the A* processing for a neighbour tile i,j.
-static void ProcessNeighbour(u16 pi, u16 pj, u16 i, u16 j, u32 pg, PathfinderState& state)
+static void ProcessNeighbour(const u16 pi, const u16 pj, const PathfindTile &pTile, 
+                             const u16 i,  const u16 j,  const u32 pg, 
+                             PathfinderState& state)
 {
 #if PATHFIND_STATS
     state.numProcessed++;
 #endif
 
     // Reject impassable tiles
-    TerrainTile tileTag = state.terrain->get(i, j);
+    const TerrainTile tileTag = state.terrain->get(i, j);
     if (!IS_PASSABLE(tileTag, state.passClass) && !state.ignoreImpassable)
         return;
 
-    u32 dg = CalculateCostDelta(pi, pj, i, j, state.tiles, state.moveCosts.at(GET_COST_CLASS(tileTag)));
+    const u32 dg = CalculateCostDelta(pi, pj, pTile, i, j, state.tiles, state.moveCosts.at(GET_COST_CLASS(tileTag)));
 
-    u32 g = pg + dg; // cost to this tile = cost to predecessor + delta from predecessor
+    const u32 g = pg + dg; // cost to this tile = cost to predecessor + delta from predecessor
 
     PathfindTile& n = state.tiles->get(i, j);
 
@@ -363 +373 @@
 #endif
 }
 
-void CCmpPathfinder::ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& path)
+void CCmpPathfinder::ComputePath(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass, Path& path)
 {
     UpdateGrid();
 
@@ -384 +394 @@
         return;
     }
 
+
     // If the target is a circle, we want to aim for the edge of it (so e.g. if we're inside
     // a large circle then the heuristics will aim us directly outwards);
     // otherwise just aim at the center point. (We'll never try moving outwards to a square shape.)
@@ -397 +408 @@
 
     state.steps = 0;
 
-    state.tiles = new PathfindTileGrid(m_MapSize, m_MapSize);
+    if (m_DebugGrid)
+    {
+        state.tiles = m_DebugGrid;
+        state.tiles->reset();
+    }
+    else
+    {
+        state.tiles = new PathfindTileGrid(m_MapSize, m_MapSize);
+    }
     state.terrain = m_Grid;
 
     state.iBest = i0;
@@ -433 +452 @@
 
         // Move best tile from open to closed
         PriorityQueue::Item curr = state.open.pop();
-        u16 i = curr.id.first;
-        u16 j = curr.id.second;
-        state.tiles->get(i, j).SetStatusClosed();
+        const u16 i = curr.id.first;
+        const u16 j = curr.id.second;
+        PathfindTile &pTile = state.tiles->get(i, j);
+        pTile.SetStatusClosed();
 
         // If we've reached the destination, stop
         if (AtGoal(i, j, goal))
@@ -450 +470 @@
         // take it and forbid any further use of impassable tiles
         if (state.ignoreImpassable)
         {
-            if (i > 0 && IS_PASSABLE(state.terrain->get(i-1, j), state.passClass))
+            if (i != 0 && IS_PASSABLE(state.terrain->get(i-1, j), state.passClass))
                 state.ignoreImpassable = false;
             else if (i < m_MapSize-1 && IS_PASSABLE(state.terrain->get(i+1, j), state.passClass))
                 state.ignoreImpassable = false;
-            else if (j > 0 && IS_PASSABLE(state.terrain->get(i, j-1), state.passClass))
+            else if (j != 0 && IS_PASSABLE(state.terrain->get(i, j-1), state.passClass))
                 state.ignoreImpassable = false;
             else if (j < m_MapSize-1 && IS_PASSABLE(state.terrain->get(i, j+1), state.passClass))
                 state.ignoreImpassable = false;
         }
 
-        u32 g = state.tiles->get(i, j).cost;
-        if (i > 0)
-            ProcessNeighbour(i, j, (u16)(i-1), j, g, state);
+        const u32 g = pTile.cost;
+        if (i != 0)
+            ProcessNeighbour(i, j, pTile, (u16)(i-1), j, g, state);
         if (i < m_MapSize-1)
-            ProcessNeighbour(i, j, (u16)(i+1), j, g, state);
-        if (j > 0)
-            ProcessNeighbour(i, j, i, (u16)(j-1), g, state);
+            ProcessNeighbour(i, j, pTile, (u16)(i+1), j, g, state);
+        if (j != 0)
+            ProcessNeighbour(i, j, pTile, i, (u16)(j-1), g, state);
         if (j < m_MapSize-1)
-            ProcessNeighbour(i, j, i, (u16)(j+1), g, state);
+            ProcessNeighbour(i, j, pTile, i, (u16)(j+1), g, state);
     }
 
     // Reconstruct the path (in reverse)
@@ -487 +507 @@
     }
 
     // Save this grid for debug display
-    delete m_DebugGrid;
     m_DebugGrid = state.tiles;
     m_DebugSteps = state.steps;
 

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -56 +56 @@
 
     TerritoryOverlay(CCmpTerritoryManager& manager);
     virtual void StartRender();
-    virtual void ProcessTile(ssize_t i, ssize_t j);
+    virtual void ProcessTile(const ssize_t i, const ssize_t j);
 };
 
 class CCmpTerritoryManager : public ICmpTerritoryManager
@@ -279 +279 @@
 
 typedef PriorityQueueHeap<std::pair<u16, u16>, u32, std::greater<u32> > OpenQueue;
 
-static void ProcessNeighbour(u32 falloff, u16 i, u16 j, u32 pg, bool diagonal,
+static void ProcessNeighbour(const u32 falloff, const u16 i, const u16 j, const u32 pg, bool diagonal,
         Grid<u32>& grid, OpenQueue& queue, const Grid<u8>& costGrid)
 {
     u32 dg = falloff * costGrid.get(i, j);
@@ -291 +291 @@
     if (pg <= grid.get(i, j) + dg)
         return;
 
-    u32 g = pg - dg; // cost to this tile = cost to predecessor - falloff from predecessor
+    const u32 g = pg - dg; // cost to this tile = cost to predecessor - falloff from predecessor
 
     grid.set(i, j, g);
     OpenQueue::Item tile = { std::make_pair(i, j), g };
     queue.push(tile);
 }
 
-static void FloodFill(Grid<u32>& grid, Grid<u8>& costGrid, OpenQueue& openTiles, u32 falloff)
+static void FloodFill(Grid<u32>& grid, Grid<u8>& costGrid, OpenQueue& openTiles, const u32 falloff)
 {
     u16 tilesW = grid.m_W;
     u16 tilesH = grid.m_H;
@@ -308 +308 @@
         OpenQueue::Item tile = openTiles.pop();
 
         // Process neighbours (if they're not off the edge of the map)
-        u16 x = tile.id.first;
-        u16 z = tile.id.second;
+        const u16 x = tile.id.first;
+        const u16 z = tile.id.second;
         if (x > 0)
             ProcessNeighbour(falloff, (u16)(x-1), z, tile.rank, false, grid, openTiles, costGrid);
         if (x < tilesW-1)
@@ -343 +343 @@
     if (!cmpTerrain->IsLoaded())
         return;
 
-    u16 tilesW = cmpTerrain->GetTilesPerSide();
-    u16 tilesH = cmpTerrain->GetTilesPerSide();
+    const u16 tilesW = cmpTerrain->GetTilesPerSide();
+    const u16 tilesH = cmpTerrain->GetTilesPerSide();
 
     m_Territories = new Grid<u8>(tilesW, tilesH);
 
@@ -352 +352 @@
     Grid<u8> influenceGrid(tilesW, tilesH);
 
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
-    ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
-    ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
+    const ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
+    const ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
 
     const Grid<u16>& passGrid = cmpPathfinder->GetPassabilityGrid();
     for (u16 j = 0; j < tilesH; ++j)
     {
         for (u16 i = 0; i < tilesW; ++i)
         {
-            u16 g = passGrid.get(i, j);
+            const u16 g = passGrid.get(i, j);
             u8 cost;
             if (g & passClassUnrestricted)
                 cost = 255; // off the world; use maximum cost
@@ -416 +416 @@
     std::vector<std::pair<player_id_t, Grid<u32> > > playerGrids;
     // TODO: this is a large waste of memory; we don't really need to store
     // all the intermediate grids
-
-    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); it != influenceEntities.end(); ++it)
+    
+    Grid<u32> entityTempGrid(tilesW, tilesH);
+    for (std::map<player_id_t, std::vector<entity_id_t> >::iterator it = influenceEntities.begin(); 
+        it != influenceEntities.end(); ++it)
     {
         Grid<u32> playerGrid(tilesW, tilesH);
 
         std::vector<entity_id_t>& ents = it->second;
-        for (std::vector<entity_id_t>::iterator eit = ents.begin(); eit != ents.end(); ++eit)
+        std::vector<entity_id_t>::iterator entEnd = ents.end();
+        for (std::vector<entity_id_t>::iterator eit = ents.begin(); eit != entEnd; ++eit)
         {
             // Compute the influence map of the current entity, then add it to the player grid
+            entityTempGrid.reset();
 
-            Grid<u32> entityGrid(tilesW, tilesH);
-
             CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *eit);
             CFixedVector2D pos = cmpPosition->GetPosition2D();
             u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
@@ -442 +444 @@
             // when doing all the sums
 
             // Initialise the tile under the entity
-            entityGrid.set(i, j, weight);
+            entityTempGrid.set(i, j, weight);
             OpenQueue openTiles;
             OpenQueue::Item tile = { std::make_pair((u16)i, (i16)j), weight };
             openTiles.push(tile);
 
             // Expand influences outwards
-            FloodFill(entityGrid, influenceGrid, openTiles, falloff);
+            FloodFill(entityTempGrid, influenceGrid, openTiles, falloff);
 
             // TODO: we should do a sparse grid and only add the non-zero regions, for performance
-            for (u16 j = 0; j < entityGrid.m_H; ++j)
-                for (u16 i = 0; i < entityGrid.m_W; ++i)
-                    playerGrid.set(i, j, playerGrid.get(i, j) + entityGrid.get(i, j));
+            for (u16 j = 0; j < tilesH; ++j)
+            {
+                for (u16 i = 0; i < tilesW; ++i)
+                {
+                    playerGrid.add(i, j, entityTempGrid.get(i, j));
+                }
+            }
         }
 
         playerGrids.push_back(std::make_pair(it->first, playerGrid));
     }
 
     // Set m_Territories to the player ID with the highest influence for each tile
+    const size_t playerGridsSize = playerGrids.size();
     for (u16 j = 0; j < tilesH; ++j)
     {
         for (u16 i = 0; i < tilesW; ++i)
         {
             u32 bestWeight = 0;
-            for (size_t k = 0; k < playerGrids.size(); ++k)
+            for (size_t k = 0; k < playerGridsSize; ++k)
             {
                 u32 w = playerGrids[k].second.get(i, j);
                 if (w > bestWeight)
@@ -480 +487 @@
 
     // Detect territories connected to a 'root' influence (typically a civ center)
     // belonging to their player, and mark them with the connected flag
+    Grid<u8>& grid = *m_Territories;
+    const u16 maxi = (u16)(grid.m_W-1);
+    const u16 maxj = (u16)(grid.m_H-1);
+
+    std::vector<std::pair<u16, u16> > tileStack;
+    // TODO: pre-allocate once and for all
+    //tileStack.reserve(500);
     for (std::vector<entity_id_t>::iterator it = rootInfluenceEntities.begin(); it != rootInfluenceEntities.end(); ++it)
     {
         // (These components must be valid else the entities wouldn't be added to this list)
         CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), *it);
         CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *it);
 
-        CFixedVector2D pos = cmpPosition->GetPosition2D();
-        u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
-        u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
+        const CFixedVector2D pos = cmpPosition->GetPosition2D();
+        const u16 i = (u16)clamp((pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
+        const u16 j = (u16)clamp((pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
 
-        u8 owner = (u8)cmpOwnership->GetOwner();
+        const u8 owner = (u8)cmpOwnership->GetOwner();
 
         if (m_Territories->get(i, j) != owner)
             continue;
 
         // TODO: would be nice to refactor some of the many flood fill
         // algorithms in this component
+        tileStack.clear();
+#define MARK_AND_PUSH(ki, kj) STMT(grid.set(ki, kj, owner | TERRITORY_CONNECTED_MASK); tileStack.push_back(std::make_pair(ki, kj)); )
 
-        Grid<u8>& grid = *m_Territories;
-
-        u16 maxi = (u16)(grid.m_W-1);
-        u16 maxj = (u16)(grid.m_H-1);
-
-        std::vector<std::pair<u16, u16> > tileStack;
-
-#define MARK_AND_PUSH(i, j) STMT(grid.set(i, j, owner | TERRITORY_CONNECTED_MASK); tileStack.push_back(std::make_pair(i, j)); )
-
         MARK_AND_PUSH(i, j);
         while (!tileStack.empty())
         {
-            int ti = tileStack.back().first;
-            int tj = tileStack.back().second;
+            const int ti = tileStack.back().first;
+            const int tj = tileStack.back().second;
             tileStack.pop_back();
 
             if (ti > 0 && grid.get(ti-1, tj) == owner)
@@ -743 +750 @@
     m_TerritoryManager.CalculateTerritories();
 }
 
-void TerritoryOverlay::ProcessTile(ssize_t i, ssize_t j)
+void TerritoryOverlay::ProcessTile(const ssize_t i, const ssize_t j)
 {
     if (!m_TerritoryManager.m_Territories)
         return;

source/simulation2/components/CCmpPathfinder_Common.h

@@ -240 +240 @@
 
     virtual const Grid<u16>& GetPassabilityGrid();
 
-    virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& ret);
+    virtual void ComputePath(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass, Path& ret);
 
-    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, entity_id_t notify);
+    virtual u32 ComputePathAsync(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass, const entity_id_t notify);
 
-    virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& ret);
+    virtual void ComputeShortPath(const IObstructionTestFilter& filter, const entity_pos_t x0, const entity_pos_t z0, const entity_pos_t r, const entity_pos_t range, const Goal& goal, const pass_class_t passClass, Path& ret);
 
-    virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, bool avoidMovingUnits, entity_id_t controller, entity_id_t notify);
+    virtual u32 ComputeShortPathAsync(const entity_pos_t x0, const entity_pos_t z0, const entity_pos_t r, const entity_pos_t range, const Goal& goal, const pass_class_t passClass, const bool avoidMovingUnits, const entity_id_t controller, const entity_id_t notify);
 
-    virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass);
+    virtual void SetDebugPath(const entity_pos_t x0, const entity_pos_t z0, const Goal& goal, const pass_class_t passClass, const cost_class_t costClass);
 
     virtual void ResetDebugPath();
 
     virtual void SetDebugOverlay(bool enabled);
 
-    virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, cost_class_t costClass);
+    virtual fixed GetMovementSpeed( const entity_pos_t x0,  const entity_pos_t z0,  const cost_class_t costClass)  ;
 
-    virtual CFixedVector2D GetNearestPointOnGoal(CFixedVector2D pos, const Goal& goal);
+    virtual CFixedVector2D GetNearestPointOnGoal(const CFixedVector2D& pos, const Goal& goal) const;
 
     virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, pass_class_t passClass);
 
@@ -275 +275 @@
     /**
      * Returns the tile containing the given position
      */
-    void NearestTile(entity_pos_t x, entity_pos_t z, u16& i, u16& j)
+    void NearestTile( const entity_pos_t x,  const entity_pos_t z, u16& i, u16& j) const
     {
         i = (u16)clamp((x / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
         j = (u16)clamp((z / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
@@ -284 +284 @@
     /**
      * Returns the position of the center of the given tile
      */
-    static void TileCenter(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z)
+    static void TileCenter(const u16 i, const u16 j, entity_pos_t& x, entity_pos_t& z)  
     {
         x = entity_pos_t::FromInt(i*(int)TERRAIN_TILE_SIZE + (int)TERRAIN_TILE_SIZE/2);
         z = entity_pos_t::FromInt(j*(int)TERRAIN_TILE_SIZE + (int)TERRAIN_TILE_SIZE/2);
     }
 
-    static fixed DistanceToGoal(CFixedVector2D pos, const CCmpPathfinder::Goal& goal);
+    static fixed DistanceToGoal(const CFixedVector2D& pos, const CCmpPathfinder::Goal& goal);
 
     /**
      * Regenerates the grid based on the current obstruction list, if necessary
@@ -298 +298 @@
     void UpdateGrid();
 
     void RenderSubmit(SceneCollector& collector);
+    public:
+        
+    private:
 };
 
 #endif // INCLUDED_CCMPPATHFINDER_COMMON

source/simulation2/components/CCmpRangeManager.cpp

@@ -57 +57 @@
  * Convert an owner ID (-1 = unowned, 0 = gaia, 1..30 = players)
  * into a 32-bit mask for quick set-membership tests.
  */
-static u32 CalcOwnerMask(player_id_t owner)
+static u32 CalcOwnerMask(const player_id_t owner)
 {
     if (owner >= -1 && owner < 31)
         return 1 << (1+owner);
@@ -68 +68 @@
 /**
  * Returns LOS mask for given player.
  */
-static u32 CalcPlayerLosMask(player_id_t player)
+static u32 CalcPlayerLosMask(const player_id_t player)
 {
     if (player > 0 && player <= 16)
         return ICmpRangeManager::LOS_MASK << (2*(player-1));
@@ -78 +78 @@
 /**
  * Returns shared LOS mask for given list of players.
  */
-static u32 CalcSharedLosMask(std::vector<player_id_t> players)
+static u32 CalcSharedLosMask(const std::vector<player_id_t> &players)
 {
     u32 playerMask = 0;
     for (size_t i = 0; i < players.size(); i++)
@@ -722 +722 @@
         // no entities will move until we've finished checking all the ranges
         std::vector<std::pair<entity_id_t, CMessageRangeUpdate> > messages;
 
+        std::vector<entity_id_t> r;
+        std::vector<entity_id_t> added;
+        std::vector<entity_id_t> removed;
+
         for (std::map<tag_t, Query>::iterator it = m_Queries.begin(); it != m_Queries.end(); ++it)
         {
             Query& q = it->second;
@@ -733 +737 @@
             if (!cmpSourcePosition || !cmpSourcePosition->IsInWorld())
                 continue;
 
-            std::vector<entity_id_t> r;
+            r.clear();
             r.reserve(q.lastMatch.size());
 
             PerformQuery(q, r);
 
+            added.clear();
+            removed.clear();
             // Compute the changes vs the last match
-            std::vector<entity_id_t> added;
-            std::vector<entity_id_t> removed;
             std::set_difference(r.begin(), r.end(), q.lastMatch.begin(), q.lastMatch.end(), std::back_inserter(added));
             std::set_difference(q.lastMatch.begin(), q.lastMatch.end(), r.begin(), r.end(), std::back_inserter(removed));
 
             if (added.empty() && removed.empty())
                 continue;
 
+
             // Return the 'added' list sorted by distance from the entity
             // (Don't bother sorting 'removed' because they might not even have positions or exist any more)
-            CFixedVector2D pos = cmpSourcePosition->GetPosition2D();
+            const CFixedVector2D pos (cmpSourcePosition->GetPosition2D());
             std::stable_sort(added.begin(), added.end(), EntityDistanceOrdering(m_EntityData, pos));
 
             messages.push_back(std::make_pair(q.source, CMessageRangeUpdate(it->first)));
@@ -799 +804 @@
         CmpPtr<ICmpPosition> cmpSourcePosition(GetSimContext(), q.source);
         if (!cmpSourcePosition || !cmpSourcePosition->IsInWorld())
             return;
-        CFixedVector2D pos = cmpSourcePosition->GetPosition2D();
+        const CFixedVector2D pos (cmpSourcePosition->GetPosition2D());
 
         // Special case: range -1.0 means check all entities ignoring distance
         if (q.maxRange == entity_pos_t::FromInt(-1))
@@ -815 +820 @@
         else
         {
             // Get a quick list of entities that are potentially in range
-            std::vector<entity_id_t> ents = m_Subdivision.GetNear(pos, q.maxRange);
+            std::vector<entity_id_t> ents;
+            m_Subdivision.GetNear(pos, q.maxRange, ents);
 
             for (size_t i = 0; i < ents.size(); ++i)
             {
@@ -826 +832 @@
                     continue;
 
                 // Restrict based on precise distance
-                int distVsMax = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.maxRange);
+                const int distVsMax = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.maxRange);
                 if (distVsMax > 0)
                     continue;
 
                 if (!q.minRange.IsZero())
                 {
-                    int distVsMin = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange);
+                    const int distVsMin = (CFixedVector2D(it->second.x, it->second.z) - pos).CompareLength(q.minRange);
                     if (distVsMin < 0)
                         continue;
                 }
@@ -970 +976 @@
 
     // LOS implementation:
 
-    virtual CLosQuerier GetLosQuerier(player_id_t player)
+    virtual CLosQuerier GetLosQuerier(const player_id_t player)
     {
         if (GetLosRevealAll(player))
             return CLosQuerier(0xFFFFFFFFu, m_LosStateRevealed, m_TerrainVerticesPerSide);
@@ -978 +984 @@
             return CLosQuerier(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
     }
 
-    virtual ELosVisibility GetLosVisibility(entity_id_t ent, player_id_t player, bool forceRetainInFog)
+    virtual ELosVisibility GetLosVisibility(const entity_id_t ent, const player_id_t player, const bool forceRetainInFog)
     {
         // (We can't use m_EntityData since this needs to handle LOCAL entities too)
 
@@ -987 +993 @@
         if (!cmpPosition || !cmpPosition->IsInWorld())
             return VIS_HIDDEN;
 
-        CFixedVector2D pos = cmpPosition->GetPosition2D();
+        const CFixedVector2D pos (cmpPosition->GetPosition2D());
 
-        int i = (pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
-        int j = (pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
+        const int i = (pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
+        const int j = (pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
 
         // Reveal flag makes all positioned entities visible
         if (GetLosRevealAll(player))
@@ -1019 +1025 @@
         return VIS_HIDDEN;
     }
 
-    virtual void SetLosRevealAll(player_id_t player, bool enabled)
+    virtual void SetLosRevealAll(const player_id_t player, const bool enabled)
     {
         m_LosRevealAll[player] = enabled;
     }
 
-    virtual bool GetLosRevealAll(player_id_t player)
+    virtual bool GetLosRevealAll(const player_id_t player)
     {
         std::map<player_id_t, bool>::const_iterator it;
 
@@ -1041 +1047 @@
         return false;
     }
 
-    virtual void SetLosCircular(bool enabled)
+    virtual void SetLosCircular(const bool enabled)
     {
         m_LosCircular = enabled;
 
@@ -1058 +1064 @@
         m_SharedLosMasks[player] = CalcSharedLosMask(players);
     }
 
-    virtual u32 GetSharedLosMask(player_id_t player)
+    virtual u32 GetSharedLosMask(const player_id_t player)
     {
         std::map<player_id_t, u32>::const_iterator it = m_SharedLosMasks.find(player);
         ENSURE(it != m_SharedLosMasks.end());
@@ -1098 +1104 @@
      * Returns whether the given vertex is outside the normal bounds of the world
      * (i.e. outside the range of a circular map)
      */
-    inline bool LosIsOffWorld(ssize_t i, ssize_t j)
+    inline bool LosIsOffWorld(const ssize_t i, const ssize_t j) const
     {
         // WARNING: CCmpObstructionManager::Rasterise needs to be kept in sync with this
         const ssize_t edgeSize = 3; // number of vertexes around the edge that will be off-world
@@ -1107 +1113 @@
         {
             // With a circular map, vertex is off-world if hypot(i - size/2, j - size/2) >= size/2:
 
-            ssize_t dist2 = (i - m_TerrainVerticesPerSide/2)*(i - m_TerrainVerticesPerSide/2)
+            const ssize_t dist2 = (i - m_TerrainVerticesPerSide/2)*(i - m_TerrainVerticesPerSide/2)
                     + (j - m_TerrainVerticesPerSide/2)*(j - m_TerrainVerticesPerSide/2);
 
-            ssize_t r = m_TerrainVerticesPerSide/2 - edgeSize + 1;
+            const ssize_t r = m_TerrainVerticesPerSide/2 - edgeSize + 1;
                 // subtract a bit from the radius to ensure nice
                 // SoD blurring around the edges of the map
 
@@ -1128 +1134 @@
     /**
      * Update the LOS state of tiles within a given horizontal strip (i0,j) to (i1,j) (inclusive).
      */
-    inline void LosAddStripHelper(u8 owner, i32 i0, i32 i1, i32 j, u16* counts)
+    inline void LosAddStripHelper(const u8 owner, const i32 i0, const i32 i1, const i32 j, u16* const __restrict  counts)
     {
         if (i1 < i0)
             return;
 
-        i32 idx0 = j*m_TerrainVerticesPerSide + i0;
-        i32 idx1 = j*m_TerrainVerticesPerSide + i1;
+        const i32 idx0 = j*m_TerrainVerticesPerSide + i0;
+        const i32 idx1 = j*m_TerrainVerticesPerSide + i1;
 
         for (i32 idx = idx0; idx <= idx1; ++idx)
         {
             // Increasing from zero to non-zero - move from unexplored/explored to visible+explored
             if (counts[idx] == 0)
             {
-                i32 i = i0 + idx - idx0;
+                const i32 i = i0 + idx - idx0;
                 if (!LosIsOffWorld(i, j))
                     m_LosState[idx] |= ((LOS_VISIBLE | LOS_EXPLORED) << (2*(owner-1)));
             }
@@ -1154 +1160 @@
     /**
      * Update the LOS state of tiles within a given horizontal strip (i0,j) to (i1,j) (inclusive).
      */
-    inline void LosRemoveStripHelper(u8 owner, i32 i0, i32 i1, i32 j, u16* counts)
+    inline void LosRemoveStripHelper(const u8 owner, const i32 i0, const i32 i1, const i32 j, u16* const __restrict counts)
     {
         if (i1 < i0)
             return;
 
-        i32 idx0 = j*m_TerrainVerticesPerSide + i0;
-        i32 idx1 = j*m_TerrainVerticesPerSide + i1;
+        const i32 idx0 = j*m_TerrainVerticesPerSide + i0;
+        const i32 idx1 = j*m_TerrainVerticesPerSide + i1;
 
         for (i32 idx = idx0; idx <= idx1; ++idx)
         {
@@ -1182 +1188 @@
      * Assumes owner is in the valid range.
      */
     template<bool adding>
-    void LosUpdateHelper(u8 owner, entity_pos_t visionRange, CFixedVector2D pos)
+    void LosUpdateHelper(const u8 owner, const entity_pos_t visionRange, const CFixedVector2D& pos)
     {
         if (m_TerrainVerticesPerSide == 0) // do nothing if not initialised yet
             return;
@@ -1208 +1214 @@
 
         // Compute top/bottom coordinates, and clamp to exclude the 1-tile border around the map
         // (so that we never render the sharp edge of the map)
-        i32 j0 = ((pos.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1 = ((pos.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
-        i32 j0clamp = std::max(j0, 1);
-        i32 j1clamp = std::min(j1, m_TerrainVerticesPerSide-2);
+        const i32 j0 = ((pos.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
+        const i32 j1 = ((pos.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        const i32 j0clamp = std::max(j0, 1);
+        const i32 j1clamp = std::min(j1, m_TerrainVerticesPerSide-2);
 
         // Translate world coordinates into fractional tile-space coordinates
-        entity_pos_t x = pos.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y = pos.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r2 = r.Square();
+        const entity_pos_t x = pos.X / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t y = pos.Y / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t r2 = r.Square();
 
         // Compute the integers on either side of x
-        i32 xfloor = (x - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
-        i32 xceil = (x + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
+        const i32 xfloor = (x - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
+        const i32 xceil = (x + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
 
         // Initialise the strip (i0, i1) to a rough guess
         i32 i0 = xfloor;
@@ -1257 +1263 @@
 
             // Clamp the strip to exclude the 1-tile border,
             // then add or remove the strip as requested
-            i32 i0clamp = std::max(i0, 1);
-            i32 i1clamp = std::min(i1, m_TerrainVerticesPerSide-2);
+            const i32 i0clamp = std::max(i0, 1);
+            const i32 i1clamp = std::min(i1, m_TerrainVerticesPerSide-2);
             if (adding)
                 LosAddStripHelper(owner, i0clamp, i1clamp, j, countsData);
             else
@@ -1271 +1277 @@
      * by removing visibility around the 'from' position
      * and then adding visibility around the 'to' position.
      */
-    void LosUpdateHelperIncremental(u8 owner, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
+    void LosUpdateHelperIncremental(const u8 owner, const entity_pos_t visionRange, const CFixedVector2D& from, const CFixedVector2D& to)
     {
         if (m_TerrainVerticesPerSide == 0) // do nothing if not initialised yet
             return;
@@ -1284 +1290 @@
         if (counts.empty())
             counts.resize(m_TerrainVerticesPerSide*m_TerrainVerticesPerSide);
 
-        u16* countsData = &counts[0];
+        u16* const __restrict countsData = &counts[0];
 
         // See comments in LosUpdateHelper.
         // This does exactly the same, except computing the strips for
@@ -1293 +1299 @@
         // so we can compute the difference between the removed/added strips
         // and only have to touch tiles that have a net change.)
 
-        i32 j0_from = ((from.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1_from = ((from.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
-        i32 j0_to = ((to.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
-        i32 j1_to = ((to.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
-        i32 j0clamp = std::max(std::min(j0_from, j0_to), 1);
-        i32 j1clamp = std::min(std::max(j1_from, j1_to), m_TerrainVerticesPerSide-2);
+        const i32 j0_from = ((from.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
+        const i32 j1_from = ((from.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        const i32 j0_to = ((to.Y - visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
+        const i32 j1_to = ((to.Y + visionRange)/(int)TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        const i32 j0clamp = std::max(std::min(j0_from, j0_to), 1);
+        const i32 j1clamp = std::min(std::max(j1_from, j1_to), m_TerrainVerticesPerSide-2);
 
-        entity_pos_t x_from = from.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y_from = from.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t x_to = to.X / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t y_to = to.Y / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
-        entity_pos_t r2 = r.Square();
+        const entity_pos_t x_from = from.X / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t y_from = from.Y / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t x_to = to.X / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t y_to = to.Y / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t r = visionRange / (int)TERRAIN_TILE_SIZE;
+        const entity_pos_t r2 = r.Square();
 
-        i32 xfloor_from = (x_from - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
-        i32 xceil_from = (x_from + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
-        i32 xfloor_to = (x_to - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
-        i32 xceil_to = (x_to + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
+        const i32 xfloor_from = (x_from - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
+        const i32 xceil_from = (x_from + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
+        const i32 xfloor_to = (x_to - entity_pos_t::Epsilon()).ToInt_RoundToNegInfinity();
+        const i32 xceil_to = (x_to + entity_pos_t::Epsilon()).ToInt_RoundToInfinity();
 
         i32 i0_from = xfloor_from;
         i32 i1_from = xceil_from;
@@ -1319 +1325 @@
 
         for (i32 j = j0clamp; j <= j1clamp; ++j)
         {
-            entity_pos_t dy_from = entity_pos_t::FromInt(j) - y_from;
-            entity_pos_t dy2_from = dy_from.Square();
+            const entity_pos_t dy_from = entity_pos_t::FromInt(j) - y_from;
+            const entity_pos_t dy2_from = dy_from.Square();
             while (dy2_from + (entity_pos_t::FromInt(i0_from-1) - x_from).Square() <= r2)
                 --i0_from;
             while (i0_from < xceil_from && dy2_from + (entity_pos_t::FromInt(i0_from) - x_from).Square() > r2)
@@ -1330 +1336 @@
             while (i1_from > xfloor_from && dy2_from + (entity_pos_t::FromInt(i1_from) - x_from).Square() > r2)
                 --i1_from;
 
-            entity_pos_t dy_to = entity_pos_t::FromInt(j) - y_to;
-            entity_pos_t dy2_to = dy_to.Square();
+            const entity_pos_t dy_to = entity_pos_t::FromInt(j) - y_to;
+            const entity_pos_t dy2_to = dy_to.Square();
             while (dy2_to + (entity_pos_t::FromInt(i0_to-1) - x_to).Square() <= r2)
                 --i0_to;
             while (i0_to < xceil_to && dy2_to + (entity_pos_t::FromInt(i0_to) - x_to).Square() > r2)
@@ -1361 +1367 @@
             // Check whether this strip moved at all
             if (!(i0_to == i0_from && i1_to == i1_from))
             {
-                i32 i0clamp_from = std::max(i0_from, 1);
-                i32 i1clamp_from = std::min(i1_from, m_TerrainVerticesPerSide-2);
-                i32 i0clamp_to = std::max(i0_to, 1);
-                i32 i1clamp_to = std::min(i1_to, m_TerrainVerticesPerSide-2);
+                const i32 i0clamp_from = std::max(i0_from, 1);
+                const i32 i1clamp_from = std::min(i1_from, m_TerrainVerticesPerSide-2);
+                const i32 i0clamp_to = std::max(i0_to, 1);
+                const i32 i1clamp_to = std::min(i1_to, m_TerrainVerticesPerSide-2);
 
                 // Check whether one strip is negative width,
                 // and we can just add/remove the entire other strip
@@ -1396 +1402 @@
         }
     }
 
-    void LosAdd(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
+    void LosAdd(const player_id_t owner, const entity_pos_t visionRange, const CFixedVector2D& pos)
     {
         if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
             return;
@@ -1404 +1410 @@
         LosUpdateHelper<true>((u8)owner, visionRange, pos);
     }
 
-    void LosRemove(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
+    void LosRemove(const player_id_t owner, const entity_pos_t visionRange, const CFixedVector2D& pos)
     {
         if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
             return;
@@ -1412 +1418 @@
         LosUpdateHelper<false>((u8)owner, visionRange, pos);
     }
 
-    void LosMove(player_id_t owner, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
+    void LosMove(const player_id_t owner, const entity_pos_t visionRange, const CFixedVector2D& from, const CFixedVector2D& to)
     {
         if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
             return;
@@ -1432 +1438 @@
         }
     }
 
-    virtual i32 GetPercentMapExplored(player_id_t player)
+    virtual i32 GetPercentMapExplored(const player_id_t player)
     {
         i32 exploredVertices = 0;
         i32 overallVisibleVertices = 0;